Introduction

RMP biases chicken gut microbiota development and microbial interactions.

Load the packages

rm(list = ls())

# CRAN
packages_from_cran = c('openxlsx','dplyr','tibble','reshape2','ggplot2','patchwork','vegan') 
for(p in packages_from_cran){if (!requireNamespace(p)){install.packages(p)}
    library(p, character.only = TRUE, quietly = TRUE, warn.conflicts = FALSE)}
## Loading required namespace: openxlsx
## Loading required namespace: dplyr
## Loading required namespace: reshape2
## Loading required namespace: ggplot2
## Warning: package 'ggplot2' was built under R version 4.1.2
## Loading required namespace: patchwork
## Loading required namespace: vegan
## Warning: package 'vegan' was built under R version 4.1.2
## Warning: package 'permute' was built under R version 4.1.2
## This is vegan 2.6-4

Figure 2A Changes in the absolute abundance and relative abundance of the main phyla (Firmicutes and Ascomycota) and the main genera (Lactobacillus and Candida) in the broiler gut microbiota. Red lines: absolute abundance of taxa; blue liens: relative abundance of taxa

ab_temp <- read.xlsx('../Data/01qpcr/01data_for_quantitive.xlsx',sheet = 2)
raw_16S <- read.csv('../Data/02micro/16S/level-2.csv')
format_16S <- raw_16S %>%
  remove_rownames %>% 
  column_to_rownames(var="index") %>%
  mutate(sum = rowSums(across(where(is.numeric)))) %>%
  select(-c('D_0__Archaea.D_1__Euryarchaeota')) %>%
  mutate(across(D_0__Bacteria.D_1__Acidobacteria:D_0__Bacteria.D_1__Zixibacteria, ~ . / sum)) %>%
  select(-c('sum')) %>%
  setNames(gsub("D_0__Bacteria.D_1__", "", names(.))) %>%
  mutate(DPH = rep(c(1,4,7,14,21,28,35,42),each = 40)) %>%
  mutate(Group1 = factor(Group1, levels = c('Duodenum','Jejunum','Ileum','Cecum'))) %>%
  select(c('Firmicutes','DPH','Group1')) 

raw_ITS <- read.csv('../Data/02micro/ITS/level-2.csv')
format_ITS <- raw_ITS %>%
  remove_rownames %>% 
  column_to_rownames(var="index") %>%
  mutate(sum = rowSums(across(where(is.numeric)))) %>%
  select(-c('k__Fungi.p__unidentified')) %>%
  mutate(across(k__Fungi.p__Ascomycota:k__Fungi.p__Rozellomycota, ~ . / sum)) %>%
  select(-c('sum')) %>%
  setNames(gsub("k__Fungi.p__", "", names(.))) %>%
  mutate(DPH = rep(c(1,4,7,14,21,28,35,42),each = 40)) %>%
  mutate(Group1 = factor(Group1, levels = c('Duodenum','Jejunum','Ileum','Cecum'))) %>%
  select(c('Ascomycota','DPH','Group1')) 

for(i in 1:nrow(ab_temp)){
  format_16S$Firmicutes2[i] <- format_16S$Firmicutes[i] * 10^(ab_temp$`log10(16S)`[i])
  format_ITS$Ascomycota2[i] <- format_ITS$Ascomycota[i] * 10^(ab_temp$`log10(ITS)`[i])
}
f12_1 <- ggplot(format_16S, aes(x=DPH)) +
  geom_smooth(aes(y=Firmicutes),color = '#4DBBD5') +
  geom_smooth(aes(y = log10(Firmicutes2+1)/10), color = '#E64B35') + 
  facet_wrap(.~Group1,nrow = 1) +
  scale_y_continuous(name = "Relative abundance", sec.axis = sec_axis(~.*10, name="Number of copies (log10)"))+
  theme_bw() +
  theme(axis.text.x = element_text(angle = 90, vjust = 1, hjust = 1),
        panel.grid.minor = element_line(color = NA)) +
  ggtitle('Firmicutes') +
  scale_x_continuous(breaks = c(1,7,14,21,28,35,42)) 
f12_2 <- ggplot(format_ITS, aes(x=DPH)) +
  geom_smooth(aes(y=Ascomycota),color = '#4DBBD5') +
  geom_smooth(aes(y = log10(Ascomycota2+1)/10), color = '#E64B35') + 
  facet_wrap(.~Group1,nrow = 1) +
  scale_y_continuous(
    name = "Relative abundance", 
    sec.axis = sec_axis(~.*10, name="Number of copies (log10)"))+
  theme_bw() +
  theme(axis.text.x = element_text(angle = 90, vjust = 1, hjust = 1),
        panel.grid.minor = element_line(color = NA),
        legend.position = 'none') +
  ggtitle('Ascomycota') +
  scale_x_continuous(breaks = c(1,7,14,21,28,35,42)) 
raw_16S_L6 <- read.csv('../Data/02micro/16S/level-6_no_archaea.csv')
format_16S_L6 <- raw_16S_L6 %>%
  remove_rownames %>% 
  column_to_rownames(var="index") %>%
  mutate(sum = rowSums(across(where(is.numeric)))) %>%
  mutate(across(Granulicella:uncultured.bacterium.40, ~ . / sum)) %>%
  select(-c('sum')) %>%
  mutate(DPH = rep(c(1,4,7,14,21,28,35,42), each = 40)) %>%
  mutate(Group1 = factor(Group1, levels = c('Duodenum','Jejunum','Ileum','Cecum'))) %>%
  select(c('Lactobacillus','DPH','Group1'))

raw_ITS_L6 <- read.csv('../Data/02micro/ITS/level-6_for_bar.csv')
format_ITS_L6 <- raw_ITS_L6 %>%
  remove_rownames %>% 
  column_to_rownames(var="X") %>%
  mutate(sum = rowSums(across(where(is.numeric)))) %>%
  mutate(across(X__:unidentified.53, ~ . / sum)) %>%
  select(-c('sum')) %>%
  mutate(DPH = rep(c(1,4,7,14,21,28,35,42), each = 40)) %>%
  mutate(Group1 = factor(Group1, levels = c('Duodenum','Jejunum','Ileum','Cecum'))) %>%
  select(c('Candida','DPH','Group1'))

for(i in 1:nrow(ab_temp)){
  format_16S_L6$Lactobacillus2[i] <- format_16S_L6$Lactobacillus[i] * 10^(ab_temp$`log10(16S)`[i])
  format_ITS_L6$Candida2[i] <- format_ITS_L6$Candida[i] * 10^(ab_temp$`log10(ITS)`[i])
}

f12_3 <- ggplot(format_16S_L6, aes(x=DPH)) +
  geom_smooth(aes(y=Lactobacillus),color = '#4DBBD5') +
  geom_smooth(aes(y = log10(Lactobacillus2+1)/10), color = '#E64B35') + 
  facet_wrap(.~Group1,nrow = 1) +
  scale_y_continuous(name = "Relative abundance", sec.axis = sec_axis(~.*10, name="Number of copies (log10)"))+
  theme_bw() +
  theme(axis.text.x = element_text(angle = 90, vjust = 1, hjust = 1),
        panel.grid.minor = element_line(color = NA)) +
  ggtitle('Lactobacillus') +
  scale_x_continuous(breaks = c(1,7,14,21,28,35,42)) 

f12_4 <- ggplot(format_ITS_L6, aes(x=DPH)) +
  geom_smooth(aes(y=Candida),color = '#4DBBD5') +
  geom_smooth(aes(y = log10(Candida2+1)/10), color = '#E64B35') + 
  facet_wrap(.~Group1,nrow = 1) +
  scale_y_continuous(name = "Relative abundance", sec.axis = sec_axis(~.*10, name="Number of copies (log10)"))+
  theme_bw() +
  theme(axis.text.x = element_text(angle = 90, vjust = 1, hjust = 1),
        panel.grid.minor = element_line(color = NA)) +
  ggtitle('Candida') +
  scale_x_continuous(breaks = c(1,7,14,21,28,35,42)) 

f12_1 + f12_2 + f12_3 + f12_4 + plot_layout(nrow = 2)
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'

Figure 2B Procrustes analyses of the correlation between absolute abundance and relative abundance for bacteria and fungi. Red nodes: absolute abundance of bacterial or fungal communities; blue nodes: relative abundance of bacterial or fungal communities

Figure 2C The percentage of the variance of the gut microbiota explained by the factors of individuals, segments, and time.

raw_16S_L6 <- read.csv('../Data/02micro/16S/level-6_no_archaea.csv')
raw_ITS_L6 <- read.csv('../Data/02micro/ITS/level-6_for_bar.csv')
format_16S_L6 <- raw_16S_L6 %>%
  remove_rownames %>% 
  column_to_rownames(var="index") %>%
  mutate(sum = rowSums(across(where(is.numeric)))) %>%
  mutate(across(Granulicella:uncultured.bacterium.40, ~ . / sum)) %>%
  select(-c('sum')) %>%
  mutate(Group1 = factor(Group1, levels = c('Duodenum','Jejunum','Ileum','Cecum'))) %>%
  select(-c('Group2'))

format_ITS_L6 <- raw_ITS_L6 %>%
  remove_rownames %>% 
  column_to_rownames(var="X") %>%
  mutate(sum = rowSums(across(where(is.numeric)))) %>%
  mutate(across(X__:unidentified.53, ~ . / sum)) %>%
  select(-c('sum')) %>%
  mutate(Group1 = factor(Group1, levels = c('Duodenum','Jejunum','Ileum','Cecum'))) %>%
  select(-c('Group2'))

format_16S_L6_AA <- format_16S_L6
format_ITS_L6_AA <- format_ITS_L6

for(i in 1:nrow(ab_temp)){
  format_16S_L6_AA[i,1:529] <- format_16S_L6[i,1:529] * 10^(ab_temp$`log10(16S)`[i])
  format_ITS_L6_AA[i,1:603] <- format_ITS_L6[i,1:603] * 10^(ab_temp$`log10(ITS)`[i])
}

dist_16S_RA <- vegdist(format_16S_L6[,1:529])
dist_ITS_RA <- vegdist(format_ITS_L6[,1:603])
dist_16S_AA <- vegdist(format_16S_L6_AA[,1:529])
dist_ITS_AA <- vegdist(format_ITS_L6_AA[,1:603])
PA_16S <- procrustes(dist_16S_AA,dist_16S_RA)
PA_ITS <- procrustes(dist_ITS_AA,dist_ITS_RA)
residual_16S <- data.frame(residuals(PA_16S))
residual_ITS <- data.frame(residuals(PA_ITS))

PA_16S_XY <- data.frame(AA_x = PA_16S$X[,1], AA_y = PA_16S$X[,2],
                        RA_x = PA_16S$Yrot[,1], RA_y = PA_16S$Yrot[,2])
PA_ITS_XY <- data.frame(AA_x = PA_ITS$X[,1], AA_y = PA_ITS$X[,2],
                        RA_x = PA_ITS$Yrot[,1], RA_y = PA_ITS$Yrot[,2])

protest(dist_16S_AA,dist_16S_RA)
## 
## Call:
## protest(X = dist_16S_AA, Y = dist_16S_RA) 
## 
## Procrustes Sum of Squares (m12 squared):        0.6137 
## Correlation in a symmetric Procrustes rotation: 0.6215 
## Significance:  0.001 
## 
## Permutation: free
## Number of permutations: 999
protest(dist_ITS_AA,dist_ITS_RA)
## 
## Call:
## protest(X = dist_ITS_AA, Y = dist_ITS_RA) 
## 
## Procrustes Sum of Squares (m12 squared):        0.789 
## Correlation in a symmetric Procrustes rotation: 0.4593 
## Significance:  0.001 
## 
## Permutation: free
## Number of permutations: 999
f13_1 <- ggplot(PA_16S_XY) +
  geom_segment(aes(x = RA_x, y = RA_y, xend = AA_x, yend = AA_y, color = 'gray'), alpha = 0.3) +
  geom_point(aes(x = RA_x, y = RA_y, color = '#4DBBD5')) +
  geom_point(aes(x = AA_x, y = AA_y, color = '#E64B35')) +
  theme_bw() +
  xlab('PCoA 1') + 
  ylab('PCoA 2') +
  theme(panel.grid.major=element_line(colour=NA),panel.grid.minor = element_line(colour=NA),
        legend.position = c(0.2,0.3)) +
  annotate('text', x = -0.7, y = -0.25, label = 'P = 0.001\nCorrelation = 0.622') +
  scale_color_manual(name = 'Method',values = c('#4DBBD5','#E64B35','gray')) + 
  ggtitle('Bacteria') 
f13_2 <- ggplot(PA_ITS_XY) +
  geom_segment(aes(x = RA_x, y = RA_y, xend = AA_x, yend = AA_y, color = 'gray'), alpha = 0.3) +
  geom_point(aes(x = RA_x, y = RA_y, color = '#4DBBD5')) +
  geom_point(aes(x = AA_x, y = AA_y, color = '#E64B35')) +
  theme_bw() +
  xlab('PCoA 1') + 
  ylab('PCoA 2') +
  theme(panel.grid.major=element_line(colour=NA),panel.grid.minor = element_line(colour=NA),
        legend.position = c(0.2,0.3))  +
  scale_color_manual(name = 'Method',values = c('#4DBBD5','#E64B35','gray')) +
  annotate('text', x = -0.6, y = 0, label = 'P = 0.001\nCorrelation = 0.459') +
  ggtitle('Fungi')

dph <- rep(c(1,4,7,14,21,28,35,42), each = 40)
set.seed(1234)
adonis(format_16S_L6[,1:529]~ format_16S_L6$Group1 + dph )
## 'adonis' will be deprecated: use 'adonis2' instead
## $aov.tab
## Permutation: free
## Number of permutations: 999
## 
## Terms added sequentially (first to last)
## 
##                       Df SumsOfSqs MeanSqs F.Model      R2 Pr(>F)    
## format_16S_L6$Group1   3    27.172  9.0572  58.379 0.32672  0.001 ***
## dph                    1     7.123  7.1234  45.915 0.08565  0.001 ***
## Residuals            315    48.870  0.1551         0.58763           
## Total                319    83.165                 1.00000           
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## $call
## adonis(formula = format_16S_L6[, 1:529] ~ format_16S_L6$Group1 + 
##     dph)
## 
## $coefficients
##                        Granulicella    Bryobacter           X__ Blastocatella
## (Intercept)            2.255215e-06  2.969140e-06  1.263935e-06  5.587656e-07
## format_16S_L6$Group11  3.566747e-06  1.837830e-05  2.069804e-06 -3.779045e-07
## format_16S_L6$Group12 -9.068283e-07 -6.126100e-06 -6.899347e-07 -3.779045e-07
## format_16S_L6$Group13 -1.329959e-06 -6.126100e-06 -6.899347e-07 -3.779045e-07
## dph                   -4.869767e-08  1.661558e-07 -3.021054e-08 -9.519005e-09
##                          uncultured          RB41         X__.1
## (Intercept)            8.242628e-07  1.213589e-06  1.053566e-06
## format_16S_L6$Group11 -1.019415e-06  2.387164e-06  1.668101e-06
## format_16S_L6$Group12 -1.019415e-06 -1.110122e-06 -5.560336e-07
## format_16S_L6$Group13 -1.019415e-06 -1.669212e-07 -5.560336e-07
## dph                    1.027119e-08 -5.445634e-09 -2.618592e-08
##                       uncultured.bacterium         X__.2 uncultured.bacterium.1
## (Intercept)                   1.111040e-06  9.646389e-07           1.911881e-06
## format_16S_L6$Group11         2.967416e-06  3.579081e-06           3.481827e-06
## format_16S_L6$Group12        -9.891388e-07 -1.193027e-06          -1.160609e-06
## format_16S_L6$Group13        -9.891388e-07 -1.193027e-06          -1.160609e-06
## dph                          -6.415836e-09  1.202042e-08          -3.954067e-08
##                               X__.3 bacterium.YC.LK.LKJ36         X__.4
## (Intercept)            2.371095e-06         -3.113149e-06 -1.098216e-06
## format_16S_L6$Group11  8.093074e-06          2.655760e-05  2.155407e-05
## format_16S_L6$Group12 -2.697691e-06         -8.852534e-06 -7.184688e-06
## format_16S_L6$Group13 -2.697691e-06         -8.852534e-06 -7.184688e-06
## dph                    1.718928e-08          6.297728e-07  4.359423e-07
##                       uncultured.Acidimicrobidae.bacterium
## (Intercept)                                   3.672076e-07
## format_16S_L6$Group11                         3.139680e-06
## format_16S_L6$Group12                        -1.046560e-06
## format_16S_L6$Group13                        -1.046560e-06
## dph                                           3.575539e-08
##                       uncultured.Actinomycetales.bacterium         X__.5
## (Intercept)                                   2.019149e-06  4.044934e-07
## format_16S_L6$Group11                         5.224460e-06  2.171745e-06
## format_16S_L6$Group12                        -1.741487e-06 -7.239150e-07
## format_16S_L6$Group13                        -1.741487e-06 -7.239150e-07
## dph                                          -1.461378e-08  1.681166e-08
##                       CL500.29.marine.group uncultured.bacterium.2
## (Intercept)                   -2.414520e-06           1.042594e-06
## format_16S_L6$Group11          6.028708e-06           1.856883e-06
## format_16S_L6$Group12         -2.009569e-06          -6.189610e-07
## format_16S_L6$Group13         -2.009569e-06          -6.189610e-07
## dph                            2.328468e-07          -2.229648e-08
##                       uncultured.Acidimicrobiales.bacterium   Actinomyces
## (Intercept)                                    1.954169e-06  4.588859e-06
## format_16S_L6$Group11                          2.463083e-06  2.486705e-05
## format_16S_L6$Group12                         -8.210278e-07 -8.289016e-06
## format_16S_L6$Group13                         -8.210278e-07 -8.289016e-06
## dph                                           -5.963900e-08  1.947451e-07
##                       Aeriscardovia Bifidobacterium   Gardnerella
## (Intercept)            9.802300e-07    4.504555e-04  1.492202e-05
## format_16S_L6$Group11 -5.514144e-07    9.630544e-04 -8.244705e-06
## format_16S_L6$Group12 -5.514144e-07   -3.443869e-04 -1.248221e-05
## format_16S_L6$Group13 -5.514144e-07   -3.486079e-04 -1.248221e-05
## dph                   -2.256925e-08   -1.374997e-06 -1.284115e-07
##                       Corynebacterium.1    Lawsonella Mycobacterium
## (Intercept)                5.464410e-05  7.273316e-06  7.369942e-07
## format_16S_L6$Group11      5.392419e-05  3.020468e-05  3.434188e-06
## format_16S_L6$Group12     -3.774400e-05 -1.047875e-05 -1.224060e-06
## format_16S_L6$Group13      3.329786e-05 -1.047875e-05 -9.860676e-07
## dph                        6.397747e-07  1.687071e-07  2.563505e-08
##                            Nocardia   Rhodococcus Jatrophihabitans
## (Intercept)            1.342161e-06  9.642229e-07     8.176124e-07
## format_16S_L6$Group11  4.979795e-06  6.101571e-06     6.773092e-06
## format_16S_L6$Group12 -1.659932e-06 -2.033857e-06    -2.257697e-06
## format_16S_L6$Group13 -1.659932e-06 -2.033857e-06    -2.257697e-06
## dph                    1.672475e-08  5.629653e-08     7.579394e-08
##                        Blastococcus Geodermatophilus Modestobacter
## (Intercept)            1.608193e-05     1.514574e-06  1.452451e-06
## format_16S_L6$Group11  3.528022e-05     5.687514e-06  1.970966e-06
## format_16S_L6$Group12 -1.176007e-05    -1.895838e-06 -6.569885e-07
## format_16S_L6$Group13 -1.176007e-05    -1.895838e-06 -6.569885e-07
## dph                   -2.274663e-07     2.006652e-08 -4.186643e-08
##                          hgcI.clade Brevibacterium Brachybacterium
## (Intercept)            5.133200e-06   6.212647e-06    3.938105e-06
## format_16S_L6$Group11 -2.509547e-06  -2.948297e-06   -2.012896e-06
## format_16S_L6$Group12 -1.439750e-06  -2.802504e-06   -7.103925e-07
## format_16S_L6$Group13  7.827327e-06   8.699097e-06    4.736185e-06
## dph                   -6.606152e-08  -1.718079e-07   -1.013268e-07
##                             Yimella  Arthrobacter       Kocuria
## (Intercept)            7.081389e-06  1.281950e-06 -6.957841e-07
## format_16S_L6$Group11  7.801975e-06  4.756395e-06 -1.574814e-06
## format_16S_L6$Group12 -2.600658e-06 -1.585465e-06  1.159569e-05
## format_16S_L6$Group13 -2.600658e-06 -1.585465e-06 -3.661326e-06
## dph                   -2.358280e-07  1.597446e-08  3.713333e-07
##                       Paenarthrobacter Pseudarthrobacter        Rothia
## (Intercept)               4.026742e-05      9.813503e-05  7.155387e-07
## format_16S_L6$Group11     1.304804e-04      3.604987e-04 -4.160560e-06
## format_16S_L6$Group12    -4.349348e-05     -1.198035e-04  8.618916e-08
## format_16S_L6$Group13    -4.349348e-05     -1.179141e-04  1.783273e-05
## dph                       1.697928e-07      1.430663e-06  1.111066e-06
##                               X__.6         X__.7 Dactylosporangium
## (Intercept)            1.526853e-05  1.161781e-06      1.272888e-06
## format_16S_L6$Group11  2.871632e-05  4.061503e-06      4.722771e-06
## format_16S_L6$Group12 -5.621542e-06 -1.353834e-06     -1.574257e-06
## format_16S_L6$Group13 -1.100466e-05 -1.353834e-06     -1.574257e-06
## dph                   -1.672848e-07  1.010805e-08      1.586153e-08
##                        uncultured.1         X__.8     Kribbella  Nocardioides
## (Intercept)           -2.034752e-06  2.361590e-06  3.722091e-06  2.155435e-05
## format_16S_L6$Group11  5.490221e-06  4.164351e-05  8.291973e-06  9.886862e-05
## format_16S_L6$Group12 -1.830074e-06 -1.511380e-05 -2.889729e-06 -2.644350e-05
## format_16S_L6$Group13 -1.830074e-06 -1.511380e-05 -2.512516e-06 -3.621256e-05
## dph                    2.034119e-07  6.711687e-07 -4.380854e-08  7.714849e-07
##                               X__.9 Cutibacterium  Microlunatus Amycolatopsis
## (Intercept)            2.162351e-06  7.206423e-05  7.810577e-07  2.013506e-06
## format_16S_L6$Group11  2.663248e-06  2.441516e-04  1.656204e-06  1.312984e-05
## format_16S_L6$Group12 -8.877492e-07 -6.270724e-05 -5.520680e-07 -4.376613e-06
## format_16S_L6$Group13 -8.877492e-07 -8.907586e-05 -5.520680e-07 -4.376613e-06
## dph                   -6.708432e-08  1.068646e-06 -1.205209e-08  1.243741e-07
##                       Lechevalieria Pseudonocardia  Streptomyces    Nonomuraea
## (Intercept)           -3.362295e-07   3.030130e-06  1.323106e-05  1.346782e-05
## format_16S_L6$Group11  1.206231e-06   9.331862e-06  3.665165e-05  3.216885e-05
## format_16S_L6$Group12 -4.020771e-07  -3.601401e-06 -1.221722e-05 -1.072295e-05
## format_16S_L6$Group13 -4.020771e-07  -3.601401e-06 -1.221722e-05 -1.072295e-05
## dph                    3.885824e-08   3.006690e-08 -5.336000e-08 -1.444667e-07
##                        Actinomadura        X__.10     Atopobium
## (Intercept)            5.995687e-07  2.252163e-06  4.337122e-07
## format_16S_L6$Group11  1.788448e-06  1.459445e-05 -4.604371e-07
## format_16S_L6$Group12 -5.961492e-07 -4.421485e-06 -4.604371e-07
## format_16S_L6$Group13 -5.961492e-07 -5.086485e-06 -4.604371e-07
## dph                   -1.799759e-10  1.491748e-07  1.406571e-09
##                       Coriobacteriaceae.UCG.002     Olsenella   Collinsella
## (Intercept)                        8.345137e-07  1.806904e-06  7.063512e-05
## format_16S_L6$Group11              3.096280e-06  3.397764e-06  1.859686e-04
## format_16S_L6$Group12             -1.032093e-06 -1.132588e-06 -6.012419e-05
## format_16S_L6$Group13             -1.032093e-06 -1.132588e-06 -7.129616e-05
## dph                                1.039892e-08 -3.549034e-08  4.239647e-07
##                            CHKCI002   Eggerthella Enterorhabdus Gordonibacter
## (Intercept)            2.605147e-04  2.680829e-07  1.595015e-07  1.712209e-06
## format_16S_L6$Group11 -2.211883e-04  3.223043e-06 -4.224990e-06 -2.057492e-06
## format_16S_L6$Group12 -1.911367e-04 -1.074348e-06 -4.224990e-06 -9.823896e-07
## format_16S_L6$Group13 -2.191938e-04 -1.074348e-06 -4.224990e-06 -2.057492e-06
## dph                   -1.484995e-06  4.243499e-08  2.139731e-07  1.817280e-08
##                              X__.11 uncultured.bacterium.3
## (Intercept)           -4.416434e-06           1.935169e-05
## format_16S_L6$Group11 -7.183429e-06           5.168224e-05
## format_16S_L6$Group12 -7.183429e-06          -1.718415e-05
## format_16S_L6$Group13 -7.183429e-06          -1.659382e-05
## dph                    6.105191e-07          -7.617960e-08
##                       uncultured.bacterium.4
## (Intercept)                     3.001006e-06
## format_16S_L6$Group11           4.615558e-06
## format_16S_L6$Group12          -1.538519e-06
## format_16S_L6$Group13          -1.538519e-06
## dph                            -7.697300e-08
##                       uncultured.Actinomycetales.bacterium.1        X__.12
## (Intercept)                                     9.882344e-07  4.751337e-06
## format_16S_L6$Group11                           4.893282e-06  1.180177e-05
## format_16S_L6$Group12                          -1.631094e-06 -3.933924e-06
## format_16S_L6$Group13                          -1.631094e-06 -3.933924e-06
## dph                                             3.383471e-08 -4.302172e-08
##                              X__.13   Rubrobacter uncultured.bacterium.5
## (Intercept)           -1.164215e-06  1.870907e-05           4.796055e-06
## format_16S_L6$Group11  2.469378e-05  6.485101e-05           8.881814e-06
## format_16S_L6$Group12 -8.231261e-06 -2.161700e-05          -9.650747e-07
## format_16S_L6$Group13 -8.231261e-06 -2.161700e-05          -3.958370e-06
## dph                    4.944987e-07  1.530493e-07          -4.408870e-08
##                              X__.14    metagenome
## (Intercept)            2.648288e-06 -2.413161e-07
## format_16S_L6$Group11  6.621304e-06  9.025347e-06
## format_16S_L6$Group12 -2.207101e-06 -3.008449e-06
## format_16S_L6$Group13 -2.207101e-06 -3.008449e-06
## dph                   -2.322037e-08  1.710403e-07
##                       uncultured.Rubrobacteraceae.bacterium
## (Intercept)                                    1.566784e-06
## format_16S_L6$Group11                          1.893991e-06
## format_16S_L6$Group12                         -1.433363e-07
## format_16S_L6$Group13                         -8.753272e-07
## dph                                           -3.639249e-08
##                       uncultured.Solirubrobacter.sp.        X__.15
## (Intercept)                             2.002988e-06  3.895318e-08
## format_16S_L6$Group11                   4.600221e-06  2.984399e-05
## format_16S_L6$Group12                  -1.533407e-06 -9.947996e-06
## format_16S_L6$Group13                  -1.533407e-06 -9.947996e-06
## dph                                    -2.471476e-08  5.215286e-07
##                        Conexibacter Parviterribacter        X__.16
## (Intercept)            9.926268e-07     2.808286e-06  5.288497e-06
## format_16S_L6$Group11  1.992581e-06     5.915407e-06  1.345569e-05
## format_16S_L6$Group12 -6.641938e-07    -1.971802e-06 -3.913362e-06
## format_16S_L6$Group13 -6.641938e-07    -1.971802e-06 -4.771163e-06
## dph                   -1.728595e-08    -4.402547e-08 -2.722812e-08
##                              X__.17   Bacteroides   Barnesiella   Coprobacter
## (Intercept)            6.764072e-07  0.0057615398  0.0014492628  6.639175e-05
## format_16S_L6$Group11  1.140608e-06 -0.0006666787 -0.0068980472 -1.688755e-04
## format_16S_L6$Group12 -3.802027e-07 -0.0097384220 -0.0036261564 -2.218142e-04
## format_16S_L6$Group13 -3.802027e-07 -0.0108535271 -0.0063333026 -2.435388e-04
## dph                   -1.558971e-08  0.0003126894  0.0002953442  9.554372e-06
##                        uncultured.2  Dysgonomonas Butyricimonas   Odoribacter
## (Intercept)            0.0010922499  1.499102e-05  3.985448e-05  1.349556e-04
## format_16S_L6$Group11 -0.0038325154  3.658711e-05  4.401672e-05 -8.939148e-04
## format_16S_L6$Group12  0.0010217951 -1.219570e-05 -1.467224e-05 -7.130529e-04
## format_16S_L6$Group13 -0.0031566369 -1.219570e-05 -1.467224e-05 -9.513318e-04
## dph                    0.0001456311 -1.471219e-07 -1.325381e-06  4.493091e-05
##                         Muribaculum  metagenome.1
## (Intercept)            3.370070e-05  5.887547e-06
## format_16S_L6$Group11  9.125726e-05  2.463234e-05
## format_16S_L6$Group12 -3.041909e-05 -8.504591e-06
## format_16S_L6$Group13 -3.041909e-05 -8.504591e-06
## dph                   -1.727164e-07  1.377391e-07
##                       uncultured.Bacteroidales.bacterium uncultured.bacterium.6
## (Intercept)                                 2.705804e-04           4.575869e-04
## format_16S_L6$Group11                       8.372037e-04          -4.558201e-04
## format_16S_L6$Group12                      -2.747195e-04          -1.755314e-03
## format_16S_L6$Group13                      -2.809988e-04          -1.637544e-03
## dph                                         7.070138e-07           7.022943e-05
##                       uncultured.organism        X__.18 Alloprevotella
## (Intercept)                  2.357727e-05  2.961791e-04   2.686224e-05
## format_16S_L6$Group11        6.535090e-05  9.202703e-04   8.658476e-05
## format_16S_L6$Group12       -2.150155e-05 -3.062030e-04  -2.973147e-05
## format_16S_L6$Group13       -2.192468e-05 -3.090838e-04  -2.972189e-05
## dph                         -8.697882e-08  7.481659e-07   1.881289e-07
##                       Paraprevotella    Prevotella  Prevotella.2  Prevotella.6
## (Intercept)             6.120326e-05  2.828402e-06  4.009996e-06 -3.275488e-07
## format_16S_L6$Group11   9.614654e-05 -1.551471e-06  3.772581e-06 -4.192525e-07
## format_16S_L6$Group12  -3.204885e-05 -1.551471e-06  4.605981e-06 -4.192525e-07
## format_16S_L6$Group13  -3.204885e-05 -1.551471e-06 -5.032212e-06 -4.192525e-07
## dph                    -1.534443e-06 -6.720688e-08  5.380085e-08  3.930533e-08
##                        Prevotella.7  Prevotella.9 Prevotellaceae.NK3B31.group
## (Intercept)            1.270342e-06  7.223675e-04                4.307285e-06
## format_16S_L6$Group11  3.392952e-06  2.350040e-03               -5.555186e-07
## format_16S_L6$Group12 -1.130984e-06 -7.651561e-04               -1.581861e-06
## format_16S_L6$Group13 -1.130984e-06 -8.517665e-04                3.719241e-06
## dph                   -7.334665e-09  7.312144e-06               -1.434433e-07
##                       Prevotellaceae.UCG.001     Alistipes     Rikenella
## (Intercept)                     1.478940e-04  0.0040026735  0.0000584655
## format_16S_L6$Group11           4.830467e-04 -0.0173063614 -0.0020662631
## format_16S_L6$Group12          -1.590161e-04 -0.0159196618 -0.0014837071
## format_16S_L6$Group13          -1.611814e-04 -0.0183153471 -0.0020205665
## dph                             7.871198e-07  0.0007975653  0.0001117304
##                       Rikenellaceae.RC9.gut.group uncultured.bacterium.7
## (Intercept)                          7.594327e-05           9.945405e-06
## format_16S_L6$Group11                2.267113e-04           2.634023e-05
## format_16S_L6$Group12               -7.551440e-05          -7.406405e-06
## format_16S_L6$Group13               -7.581992e-05          -9.466914e-06
## dph                                  1.301230e-08          -2.518370e-08
##                       Parabacteroides        X__.19  Chitinophaga
## (Intercept)              2.306102e-04  5.893162e-05  6.312366e-06
## format_16S_L6$Group11   -5.163138e-05 -1.007755e-04  8.515829e-05
## format_16S_L6$Group12   -8.309489e-04 -1.032401e-04 -2.838610e-05
## format_16S_L6$Group13   -8.712070e-04 -1.045579e-04 -2.838610e-05
## dph                      3.714100e-05  2.401383e-06  1.161775e-06
##                       Ferruginibacter Pseudoflavitalea Sediminibacterium
## (Intercept)              2.518188e-06     1.114664e-06      1.263113e-05
## format_16S_L6$Group11    2.775714e-06     3.980281e-06      2.564760e-05
## format_16S_L6$Group12   -1.044371e-06    -1.326760e-06     -5.317219e-06
## format_16S_L6$Group13   -6.869726e-07    -1.326760e-06     -1.016519e-05
## dph                     -7.756933e-08     1.116297e-08     -1.297864e-07
##                          Terrimonas Vibrionimonas  uncultured.3
## (Intercept)            7.069443e-07  1.854223e-06 -3.261129e-07
## format_16S_L6$Group11  1.257361e-06  8.295485e-06  3.325489e-06
## format_16S_L6$Group12 -4.191203e-07 -2.395061e-06 -1.108496e-06
## format_16S_L6$Group13 -4.191203e-07 -2.950212e-06 -1.108496e-06
## dph                   -1.514863e-08  5.768364e-08  7.550576e-08
##                       Candidatus.Aquirestis  uncultured.4        X__.20
## (Intercept)                    7.997704e-07  2.767178e-06  1.190570e-07
## format_16S_L6$Group11          8.589183e-06  5.926977e-06  2.578124e-06
## format_16S_L6$Group12         -2.863061e-06 -1.975659e-06 -8.593747e-07
## format_16S_L6$Group13         -2.863061e-06 -1.975659e-06 -8.593747e-07
## dph                            1.085943e-07 -4.165887e-08  3.896409e-08
##                       Rhodocytophaga  Hymenobacter  Ohtaekwangia     Arcicella
## (Intercept)             4.663901e-07  1.705333e-06  3.127915e-06  5.099947e-07
## format_16S_L6$Group11   2.327451e-06  3.891777e-06  4.076646e-06  3.878393e-06
## format_16S_L6$Group12  -7.758171e-07 -1.297259e-06 -1.358882e-06 -1.292798e-06
## format_16S_L6$Group13  -7.758171e-07 -1.297259e-06 -1.358882e-06 -1.292798e-06
## dph                     1.628563e-08 -2.147759e-08 -9.310699e-08  4.120016e-08
##                           Emticicia  Lacihabitans     Spirosoma Flavobacterium
## (Intercept)            9.287084e-07  2.397954e-06  6.242708e-07   7.006491e-05
## format_16S_L6$Group11  2.582517e-06  1.289647e-05 -7.720732e-07   2.398428e-04
## format_16S_L6$Group12 -8.608389e-07 -4.298823e-06 -7.720732e-07  -7.873356e-05
## format_16S_L6$Group13 -8.608389e-07 -4.298823e-06 -7.720732e-07  -7.972071e-05
## dph                   -3.572080e-09  1.000457e-07  7.779076e-09   5.959821e-07
##                       Chryseobacterium Cloacibacterium uncultured.bacterium.8
## (Intercept)               4.045904e-06   -1.859363e-07           4.671902e-06
## format_16S_L6$Group11    -1.661038e-06    6.308786e-07           6.156756e-06
## format_16S_L6$Group12     4.983115e-06   -2.102929e-07          -2.052252e-06
## format_16S_L6$Group13    -1.661038e-06   -2.102929e-07          -2.052252e-06
## dph                      -1.255193e-07    2.085417e-08          -1.378763e-07
##                         Olivibacter    Pedobacter
## (Intercept)            3.457431e-06  6.183350e-06
## format_16S_L6$Group11  1.455395e-05  2.064596e-05
## format_16S_L6$Group12 -5.169003e-06 -6.654460e-06
## format_16S_L6$Group13 -4.215942e-06 -6.995751e-06
## dph                    9.008276e-08  4.275798e-08
##                       uncultured.Bacteroidetes.bacterium        X__.21
## (Intercept)                                 1.575806e-06  4.087742e-06
## format_16S_L6$Group11                       1.940833e-06  4.330339e-06
## format_16S_L6$Group12                      -6.469442e-07 -9.739100e-07
## format_16S_L6$Group13                      -6.469442e-07 -1.678215e-06
## dph                                        -4.888747e-08 -1.268172e-07
##                        uncultured.5      FFCH7168 uncultured.bacterium.9
## (Intercept)            6.037243e-07  4.087765e-07           3.791886e-06
## format_16S_L6$Group11  1.283028e-06 -5.055585e-07           8.941619e-06
## format_16S_L6$Group12 -4.276760e-07 -5.055585e-07          -2.980540e-06
## format_16S_L6$Group13 -4.276760e-07 -5.055585e-07          -2.980540e-06
## dph                   -9.265699e-09  5.093788e-09          -4.270244e-08
##                       uncultured.Chloroflexi.bacterium uncultured.bacterium.10
## (Intercept)                               8.523198e-07            6.751308e-06
## format_16S_L6$Group11                     2.631006e-06            9.068436e-06
## format_16S_L6$Group12                    -8.770022e-07           -3.022812e-06
## format_16S_L6$Group13                    -8.770022e-07           -3.022812e-06
## dph                                       1.299073e-09           -1.962367e-07
##                       uncultured.bacterium.11 gut.metagenome
## (Intercept)                      6.320351e-06  -7.634412e-06
## format_16S_L6$Group11            1.208893e-05  -1.434403e-05
## format_16S_L6$Group12           -4.029644e-06  -6.228824e-06
## format_16S_L6$Group13           -4.029644e-06  -1.414371e-05
## dph                             -1.205635e-07   1.156760e-06
##                       uncultured.bacterium.12 uncultured.rumen.bacterium
## (Intercept)                     -7.892156e-05              -8.024239e-06
## format_16S_L6$Group11           -2.544203e-04              -1.396143e-04
## format_16S_L6$Group12           -2.050428e-04              -1.220794e-04
## format_16S_L6$Group13           -2.469176e-04              -1.272388e-04
## dph                              1.791920e-05               7.770448e-06
##                              X__.22 Chroococcidiopsis.SAG.2023  uncultured.6
## (Intercept)            1.664310e-05               6.219560e-07  3.492936e-06
## format_16S_L6$Group11 -8.624382e-05              -7.692104e-07 -4.319923e-06
## format_16S_L6$Group12 -8.009958e-05              -7.692104e-07 -4.319923e-06
## format_16S_L6$Group13 -8.113249e-05              -7.692104e-07 -4.319923e-06
## dph                    3.735387e-06               7.750231e-09  4.352568e-08
##                        uncultured.7 Mastigocladopsis.PCC.10914
## (Intercept)            4.303097e-06               8.651583e-07
## format_16S_L6$Group11 -2.910272e-06              -1.069993e-06
## format_16S_L6$Group12 -2.910272e-06              -1.069993e-06
## format_16S_L6$Group13 -2.910272e-06              -1.069993e-06
## dph                   -7.330660e-08               1.078079e-08
##                       Scytonema.UTEX.2349        X__.23
## (Intercept)                  3.333840e-06  1.519889e-06
## format_16S_L6$Group11       -2.254744e-06 -1.027932e-06
## format_16S_L6$Group12       -2.254744e-06 -1.027932e-06
## format_16S_L6$Group13       -2.254744e-06 -1.027932e-06
## dph                         -5.679455e-08 -2.589249e-08
##                       uncultured.cyanobacterium Mucispirillum   Meiothermus
## (Intercept)                        1.630949e-06  7.607399e-06  5.455013e-06
## format_16S_L6$Group11             -1.103044e-06  4.730025e-05  8.979778e-06
## format_16S_L6$Group12             -1.103044e-06 -1.338702e-05 -2.841575e-06
## format_16S_L6$Group13             -1.103044e-06 -1.695661e-05 -3.069102e-06
## dph                               -2.778448e-08  4.920639e-07 -1.255743e-07
##                             Thermus        X__.24 uncultured.bacterium.13
## (Intercept)            2.534099e-05  2.844947e-07            8.264874e-07
## format_16S_L6$Group11 -5.551132e-07  1.590348e-06            1.805946e-06
## format_16S_L6$Group12  2.542262e-05 -5.301160e-07           -6.019819e-07
## format_16S_L6$Group13 -1.243375e-05 -5.301160e-07           -6.019819e-07
## dph                   -6.793284e-07  1.292744e-08           -1.181608e-08
##                       uncultured.bacterium.14 Campylobacter Helicobacter
## (Intercept)                      1.051959e-06 -2.818110e-05 -0.008217719
## format_16S_L6$Group11            1.468796e-06 -3.249577e-05  0.090418638
## format_16S_L6$Group12           -4.895985e-07 -5.526260e-05 -0.043934889
## format_16S_L6$Group13           -4.895985e-07 -1.004520e-04 -0.012314453
## dph                             -2.959790e-08  7.946373e-06  0.003070386
##                       Sulfuricurvum  Sulfurimonas  Tumebacillus      Bacillus
## (Intercept)           -7.499394e-08  1.465520e-06  1.016868e-06  3.032663e-03
## format_16S_L6$Group11  5.573912e-06  1.898737e-06  1.669836e-06 -2.100397e-03
## format_16S_L6$Group12 -1.857971e-06 -6.329123e-07 -5.566121e-07 -2.273913e-03
## format_16S_L6$Group13 -1.857971e-06 -6.329123e-07 -5.566121e-07 -2.273558e-03
## dph                    1.017350e-07 -4.382146e-08 -2.422398e-08 -3.837881e-05
##                              X__.25 Exiguobacterium Paenibacillus
## (Intercept)            3.865240e-05   -1.129574e-06  2.330194e-06
## format_16S_L6$Group11 -1.921112e-05   -4.189501e-06  3.715272e-06
## format_16S_L6$Group12 -1.921112e-05    1.256850e-05 -1.238424e-06
## format_16S_L6$Group13 -1.921112e-05   -4.189501e-06 -1.238424e-06
## dph                   -1.023225e-06    2.799513e-07 -5.746160e-08
##                       Paenisporosarcina   Planococcus Planomicrobium
## (Intercept)                1.270443e-04 -1.421100e-08   1.538225e-06
## format_16S_L6$Group11      3.379018e-04  8.679445e-06   4.109121e-06
## format_16S_L6$Group12     -1.099925e-04 -2.893148e-06  -1.369707e-06
## format_16S_L6$Group13     -1.139547e-04 -2.893148e-06  -1.369707e-06
## dph                       -6.889264e-07  1.530189e-07  -8.869375e-09
##                       Jeotgalicoccus   Macrococcus Staphylococcus    Aerococcus
## (Intercept)             2.464202e-06  6.865669e-05   4.641082e-03  3.949629e-05
## format_16S_L6$Group11   3.035020e-06  3.648273e-05   1.608005e-02  4.380862e-05
## format_16S_L6$Group12  -1.011673e-06 -8.072548e-06  -5.183684e-03 -1.320582e-05
## format_16S_L6$Group13  -1.011673e-06  1.943801e-07  -5.433487e-03 -7.113029e-06
## dph                    -7.644887e-08 -2.006145e-06   5.010581e-05 -8.326068e-07
##                         Atopostipes Dolosigranulum Granulicatella  Trichococcus
## (Intercept)            5.330766e-07  -5.327063e-05   9.353563e-07  2.713114e-07
## format_16S_L6$Group11  1.663569e-06   2.456886e-04   2.328501e-06  1.583601e-06
## format_16S_L6$Group12 -5.545231e-07  -8.236937e-05  -7.761672e-07 -5.278669e-07
## format_16S_L6$Group13 -5.545231e-07  -8.713181e-05  -7.761672e-07 -5.278669e-07
## dph                    1.128761e-09   7.433493e-06  -8.378377e-09  1.350292e-08
##                       Enterococcus Lactobacillus   Leuconostoc     Weissella
## (Intercept)             0.06349693   0.371000452  1.449442e-05  2.052602e-05
## format_16S_L6$Group11   0.01488498   0.076818123  4.108349e-05  7.108789e-05
## format_16S_L6$Group12  -0.01488319   0.219998468 -1.380106e-05 -2.209010e-05
## format_16S_L6$Group13   0.01860009   0.145970670 -1.333558e-05 -2.356807e-05
## dph                    -0.00184884   0.006864395 -2.881926e-08  2.580896e-07
##                         Lactococcus Streptococcus        X__.26
## (Intercept)            7.042607e-06   0.185786593  7.761827e-07
## format_16S_L6$Group11  2.839888e-05  -0.016681382  6.162046e-06
## format_16S_L6$Group12 -8.684890e-06   0.008712452 -2.054015e-06
## format_16S_L6$Group13 -9.856997e-06   0.042794597 -2.054015e-06
## dph                    1.481258e-07  -0.005519749  6.725436e-08
##                       Christensenellaceae.R.7.group  uncultured.8        X__.27
## (Intercept)                           -0.0002033237  1.144444e-06 -3.812082e-07
## format_16S_L6$Group11                 -0.0019533493 -4.934679e-06 -1.378741e-06
## format_16S_L6$Group12                 -0.0015810280 -4.934679e-06 -1.378741e-06
## format_16S_L6$Group13                 -0.0019836426 -4.934679e-06 -1.378741e-06
## dph                                    0.0001183311  1.994861e-07  9.262892e-08
##                       Candidatus.Arthromitus Clostridium.sensu.stricto.1
## (Intercept)                     0.0377411034                0.0058867961
## format_16S_L6$Group11          -0.0214289271               -0.0013790498
## format_16S_L6$Group12           0.0206545168               -0.0020718454
## format_16S_L6$Group13           0.0223212544               -0.0021434667
## dph                            -0.0008501383               -0.0001922317
##                       Clostridium.sensu.stricto.11 gut.metagenome.1
## (Intercept)                           1.242796e-06     9.437976e-05
## format_16S_L6$Group11                 4.117649e-06    -1.496024e-04
## format_16S_L6$Group12                -1.372550e-06    -1.363284e-04
## format_16S_L6$Group13                -1.372550e-06    -1.492957e-04
## dph                                   6.829120e-09     3.115422e-06
##                       uncultured.Clostridia.bacterium
## (Intercept)                              1.901393e-04
## format_16S_L6$Group11                   -3.460994e-04
## format_16S_L6$Group12                   -1.088965e-04
## format_16S_L6$Group13                   -3.413819e-04
## dph                                      9.854577e-06
##                       uncultured.Firmicutes.bacterium
## (Intercept)                              3.561148e-03
## format_16S_L6$Group11                   -2.379345e-03
## format_16S_L6$Group12                   -2.391201e-03
## format_16S_L6$Group13                   -2.427272e-03
## dph                                     -5.844804e-05
##                       uncultured.Thermoanaerobacterales.bacterium
## (Intercept)                                          1.218044e-06
## format_16S_L6$Group11                               -1.789796e-05
## format_16S_L6$Group12                               -1.865934e-05
## format_16S_L6$Group13                               -2.008951e-05
## dph                                                  9.932351e-07
##                       uncultured.bacterium.15 uncultured.organism.1
## (Intercept)                      0.0031260023         -4.756240e-05
## format_16S_L6$Group11           -0.0049202260         -4.585773e-04
## format_16S_L6$Group12           -0.0036809944         -1.633847e-04
## format_16S_L6$Group13           -0.0048987688         -4.273345e-04
## dph                              0.0001049527          2.689341e-05
##                       uncultured.prokaryote uncultured.rumen.bacterium.1
## (Intercept)                   -1.842976e-05                 1.723675e-05
## format_16S_L6$Group11         -4.637408e-05                -7.787447e-05
## format_16S_L6$Group12         -6.859019e-06                -7.638070e-05
## format_16S_L6$Group13         -4.419893e-05                -7.787447e-05
## dph                            3.410728e-06                 3.191459e-06
##                              X__.28 Defluviitaleaceae.UCG.011  Anaerofustis
## (Intercept)            2.423336e-05              5.855535e-05  6.124373e-05
## format_16S_L6$Group11 -2.368477e-04             -7.781152e-05 -7.529996e-05
## format_16S_L6$Group12 -2.342551e-04             -5.964226e-05 -7.403776e-05
## format_16S_L6$Group13 -2.370465e-04             -7.751812e-05 -7.747645e-05
## dph                    1.122591e-05              1.111736e-06  8.794508e-07
##                        Anaerococcus     Ezakiella    Finegoldia  Gottschalkia
## (Intercept)            1.834879e-05  4.093909e-05  3.548870e-05  8.036651e-07
## format_16S_L6$Group11 -1.871802e-05 -2.895263e-05 -3.762183e-05  3.005357e-07
## format_16S_L6$Group12 -1.871802e-05 -2.895263e-05 -3.762183e-05  3.593507e-07
## format_16S_L6$Group13 -1.871802e-05 -2.895263e-05 -3.762183e-05 -3.299432e-07
## dph                    1.943321e-08 -6.308666e-07  1.122703e-07 -2.493273e-08
##                        Murdochiella    Parvimonas Peptoniphilus
## (Intercept)            1.331600e-06  4.612672e-06  1.134088e-05
## format_16S_L6$Group11 -1.262238e-06  1.045966e-05 -1.642513e-05
## format_16S_L6$Group12 -1.262238e-06 -3.486553e-06 -1.642513e-05
## format_16S_L6$Group13 -1.262238e-06 -3.486553e-06 -1.642513e-05
## dph                   -3.650642e-09 -5.926942e-08  2.675916e-07
##                       Family.XIII.AD3011.group Family.XIII.UCG.001
## (Intercept)                      -6.577167e-06        1.930183e-05
## format_16S_L6$Group11            -1.266374e-04       -3.067081e-05
## format_16S_L6$Group12            -1.231117e-04       -2.771578e-05
## format_16S_L6$Group13            -1.253855e-04       -2.984220e-05
## dph                               7.077400e-06        6.319123e-07
##                             S5.A14a X.Eubacterium..brachy.group
## (Intercept)            2.385980e-07                6.439054e-06
## format_16S_L6$Group11 -4.807276e-07               -2.682914e-05
## format_16S_L6$Group12 -4.807276e-07               -2.766064e-05
## format_16S_L6$Group13 -4.807276e-07               -2.766064e-05
## dph                    1.274366e-08                1.116926e-06
##                       X.Eubacterium..nodatum.group        X__.29        ASF356
## (Intercept)                           2.881381e-05 -1.050121e-07  3.134985e-04
## format_16S_L6$Group11                -1.003188e-04 -1.373508e-06 -1.649048e-04
## format_16S_L6$Group12                -9.315984e-05  5.878913e-07 -1.689927e-04
## format_16S_L6$Group13                -9.800354e-05 -1.373508e-06 -1.703478e-04
## dph                                   3.763420e-06  7.781687e-08 -7.534247e-06
##                       Acetitomaculum  Agathobacter  Anaerostipes       Blautia
## (Intercept)             2.504104e-06  3.921150e-04  1.356355e-03  7.857914e-03
## format_16S_L6$Group11  -1.392545e-06  5.710383e-04 -2.352418e-03 -5.165412e-03
## format_16S_L6$Group12   3.113787e-06 -1.914740e-04 -1.180220e-03 -3.987595e-03
## format_16S_L6$Group13   2.425932e-06 -2.038962e-04 -2.211106e-03 -7.021716e-03
## dph                     8.647737e-08 -9.655836e-06  5.936021e-05  1.584831e-05
##                        Butyrivibrio        CAG.56      CHKCI001 Coprococcus.2
## (Intercept)           -6.721321e-07  1.950528e-04  7.430630e-04  1.613076e-06
## format_16S_L6$Group11 -3.594512e-06 -1.554253e-04 -1.022165e-03  5.162283e-06
## format_16S_L6$Group12 -3.594512e-06 -1.409052e-04 -1.527188e-04 -1.720761e-06
## format_16S_L6$Group13 -3.594512e-06 -1.657530e-04 -1.054298e-03 -1.720761e-06
## dph                    2.245602e-07 -1.542092e-06  2.648406e-05  5.667640e-09
##                       Coprococcus.3         Dorea Eisenbergiella  Epulopiscium
## (Intercept)            1.740278e-05  5.908845e-06   3.129638e-03  5.753335e-07
## format_16S_L6$Group11  6.892532e-05  3.029987e-05  -1.761864e-03  2.796935e-07
## format_16S_L6$Group12 -2.359340e-05 -1.009996e-05  -1.682572e-03 -2.334779e-07
## format_16S_L6$Group13 -2.359340e-05 -1.009996e-05  -1.786923e-03 -2.334779e-07
## dph                    3.258221e-07  2.205848e-07  -6.523199e-05 -1.799240e-08
##                       Fusicatenibacter GCA.900066575 Lachnoclostridium
## (Intercept)               1.046738e-04  1.090151e-03      2.366092e-03
## format_16S_L6$Group11     1.842178e-04 -8.695321e-04     -1.543636e-03
## format_16S_L6$Group12    -5.211036e-05 -7.857799e-04     -1.777376e-03
## format_16S_L6$Group13    -7.111714e-05 -8.622109e-04     -1.811357e-03
## dph                      -1.498473e-06 -1.098894e-05     -2.453161e-05
##                         Lachnospira Lachnospiraceae.FCS020.group
## (Intercept)            3.013179e-04                 3.002457e-05
## format_16S_L6$Group11  5.440816e-04                -7.306644e-05
## format_16S_L6$Group12 -1.937362e-04                -6.525234e-05
## format_16S_L6$Group13 -2.223848e-04                -7.524934e-05
## dph                   -4.047081e-06                 2.380251e-06
##                       Lachnospiraceae.ND3007.group
## (Intercept)                           5.118544e-05
## format_16S_L6$Group11                 8.266482e-05
## format_16S_L6$Group12                -2.755494e-05
## format_16S_L6$Group13                -2.755494e-05
## dph                                  -1.243711e-06
##                       Lachnospiraceae.NK4A136.group Lachnospiraceae.UCG.003
## (Intercept)                            7.354595e-04            2.566600e-04
## format_16S_L6$Group11                 -1.381956e-04            2.795644e-04
## format_16S_L6$Group12                 -4.382383e-04           -9.425905e-05
## format_16S_L6$Group13                 -2.848016e-04           -9.104626e-05
## dph                                   -1.468534e-05           -8.547420e-06
##                       Lachnospiraceae.UCG.004 Lachnospiraceae.UCG.010
## (Intercept)                      3.181410e-06            5.189690e-05
## format_16S_L6$Group11            2.352312e-05           -4.078875e-05
## format_16S_L6$Group12           -8.218279e-06           -3.777121e-05
## format_16S_L6$Group13           -8.218279e-06           -4.078875e-05
## dph                              2.650984e-07           -5.846395e-07
##                       Marvinbryantia     Roseburia    Sellimonas Shuttleworthia
## (Intercept)             5.466426e-04  4.702846e-04  3.981550e-03   9.271616e-04
## format_16S_L6$Group11  -5.252557e-04  7.830282e-04 -2.426218e-03  -1.052632e-03
## format_16S_L6$Group12  -5.432217e-04 -2.896091e-04 -1.835268e-03  -9.837375e-04
## format_16S_L6$Group13  -5.419873e-04 -2.923616e-04 -2.834577e-03  -1.070113e-03
## dph                     8.159459e-07 -8.925309e-06 -4.602621e-05   1.046439e-05
##                          Tyzzerella  Tyzzerella.3  Tyzzerella.4     UC5.1.2E3
## (Intercept)            1.213509e-03  1.258260e-04  3.497240e-06  5.492419e-05
## format_16S_L6$Group11 -1.318106e-03 -1.707985e-05  5.521546e-06 -6.851451e-05
## format_16S_L6$Group12 -1.340764e-03 -7.609216e-05 -2.369853e-06 -9.240939e-05
## format_16S_L6$Group13 -1.250744e-03 -7.394777e-05 -2.369853e-06 -9.240939e-05
## dph                    1.082081e-05 -2.617573e-06 -5.933618e-08  1.972905e-06
##                       X.Eubacterium..eligens.group X.Eubacterium..hallii.group
## (Intercept)                           7.354455e-05                1.907289e-03
## format_16S_L6$Group11                 2.406554e-04               -2.169946e-03
## format_16S_L6$Group12                -8.055679e-05               -1.074031e-03
## format_16S_L6$Group13                -8.055679e-05               -2.242452e-03
## dph                                   3.690653e-07                3.811434e-05
##                       X.Eubacterium..ventriosum.group
## (Intercept)                              3.926660e-05
## format_16S_L6$Group11                   -2.010831e-05
## format_16S_L6$Group12                   -3.265976e-05
## format_16S_L6$Group13                   -3.265976e-05
## dph                                     -3.477284e-07
##                       X.Ruminococcus..gauvreauii.group
## (Intercept)                               9.761058e-04
## format_16S_L6$Group11                    -6.598144e-04
## format_16S_L6$Group12                    -5.325974e-04
## format_16S_L6$Group13                    -6.641579e-04
## dph                                      -1.163738e-05
##                       X.Ruminococcus..gnavus.group
## (Intercept)                           2.145993e-04
## format_16S_L6$Group11                 6.087013e-04
## format_16S_L6$Group12                -2.259563e-04
## format_16S_L6$Group13                -2.217863e-04
## dph                                   8.664864e-07
##                       X.Ruminococcus..torques.group  uncultured.9        X__.30
## (Intercept)                            0.0276329709  2.098227e-04  0.0176311398
## format_16S_L6$Group11                 -0.0175401799 -3.854732e-04 -0.0170568009
## format_16S_L6$Group12                 -0.0153735541 -3.999606e-04 -0.0093884925
## format_16S_L6$Group13                 -0.0186790138 -4.146034e-04 -0.0174341614
## dph                                   -0.0003795612  1.094304e-05  0.0001016609
##                         Peptococcus uncultured.10 Clostridioides
## (Intercept)           -1.803474e-07  1.854573e-05   6.384644e-06
## format_16S_L6$Group11 -4.782986e-06 -1.118946e-04   3.023127e-06
## format_16S_L6$Group12 -4.782986e-06 -9.733028e-05  -3.189941e-06
## format_16S_L6$Group13 -4.782986e-06 -1.135079e-04  -3.189941e-06
## dph                    2.612281e-07  5.175240e-06  -1.681423e-07
##                       Intestinibacter Peptostreptococcus    Romboutsia
## (Intercept)              2.135909e-05       1.127436e-07  0.0051969200
## format_16S_L6$Group11    7.101854e-05      -4.890139e-07 -0.0094636821
## format_16S_L6$Group12   -2.276708e-05      -4.890139e-07 -0.0075391450
## format_16S_L6$Group13   -2.475391e-05      -4.890139e-07  0.0245296723
## dph                      1.786750e-07       1.980370e-08  0.0003121008
##                              X__.31   Anaerofilum Anaerotruncus Angelakisella
## (Intercept)            8.205018e-03  2.387683e-03  7.264225e-04  3.810113e-05
## format_16S_L6$Group11 -3.779055e-03 -1.354834e-03 -5.774357e-04 -4.880382e-05
## format_16S_L6$Group12  4.287286e-03 -1.350127e-03 -6.022503e-04 -4.644613e-05
## format_16S_L6$Group13  6.363194e-03 -1.367852e-03 -5.850334e-04 -4.880382e-05
## dph                   -5.357169e-05 -5.265282e-05 -6.251485e-06  5.632991e-07
##                       Butyricicoccus       CAG.352 Candidatus.Soleaferrea
## (Intercept)             0.0084325998  9.281994e-06           7.612644e-05
## format_16S_L6$Group11  -0.0050360418 -1.121968e-05          -1.204872e-04
## format_16S_L6$Group12  -0.0050713108 -1.100100e-05          -1.201871e-04
## format_16S_L6$Group13  -0.0054635967 -1.121968e-05          -1.212971e-04
## dph                    -0.0001432392  1.019837e-07           2.411295e-06
##                       Caproiciproducens        DTU089 Faecalibacterium
## (Intercept)                3.633027e-04  5.718596e-04      0.002846456
## format_16S_L6$Group11     -1.860839e-04 -4.371395e-04     -0.021653942
## format_16S_L6$Group12     -1.864400e-04 -4.797908e-04     -0.009914470
## format_16S_L6$Group13     -1.876042e-04 -4.885307e-04     -0.023741049
## dph                       -9.247288e-06 -4.046124e-06      0.001266900
##                       Flavonifractor  Fournierella GCA.900066225  Harryflintia
## (Intercept)             2.130911e-03  0.0014454500  7.348815e-04  3.800712e-06
## format_16S_L6$Group11  -1.571896e-03 -0.0024731443 -5.283444e-04 -9.287615e-06
## format_16S_L6$Group12  -1.650168e-03 -0.0019640823 -5.343101e-04 -9.287615e-06
## format_16S_L6$Group13  -1.804683e-03 -0.0024833791 -5.435969e-04 -9.287615e-06
## dph                    -1.540185e-05  0.0000615532 -9.861909e-06  2.887844e-07
##                       Hydrogenoanaerobacterium Intestinimonas Negativibacillus
## (Intercept)                       3.823946e-05   2.190154e-03     2.709676e-03
## format_16S_L6$Group11            -3.783100e-05  -1.974889e-03    -2.048234e-03
## format_16S_L6$Group12            -4.197154e-05  -1.997947e-03    -1.866253e-03
## format_16S_L6$Group13            -4.060186e-05  -2.062010e-03    -2.073920e-03
## dph                               1.964257e-07  -5.600471e-06    -2.901736e-05
##                       Oscillibacter  Oscillospira Papillibacter        Phocea
## (Intercept)            1.260222e-03  7.122236e-05 -5.352162e-07 -1.847872e-06
## format_16S_L6$Group11 -8.119816e-04 -1.228363e-04 -2.114072e-06 -1.043203e-05
## format_16S_L6$Group12 -7.658334e-04 -1.289196e-04 -2.114072e-06 -1.043203e-05
## format_16S_L6$Group13 -8.429528e-04 -1.299714e-04 -2.114072e-06 -1.043203e-05
## dph                   -2.117274e-05  3.113747e-06  1.394362e-07  6.463108e-07
##                       Pseudoflavonifractor Ruminiclostridium
## (Intercept)                   5.684807e-04      7.549819e-04
## format_16S_L6$Group11        -2.734252e-04     -8.815505e-04
## format_16S_L6$Group12        -2.734252e-04     -5.491683e-04
## format_16S_L6$Group13        -2.734252e-04     -8.442630e-04
## dph                          -1.552923e-05      8.560508e-06
##                       Ruminiclostridium.1 Ruminiclostridium.5
## (Intercept)                  2.086699e-07        1.708879e-03
## format_16S_L6$Group11       -3.258686e-05       -1.366427e-03
## format_16S_L6$Group12       -2.476044e-05       -1.109458e-03
## format_16S_L6$Group13       -3.207170e-05       -1.433525e-03
## dph                          1.704116e-06       -1.200474e-05
##                       Ruminiclostridium.6 Ruminiclostridium.9
## (Intercept)                  3.542745e-06        0.0027995845
## format_16S_L6$Group11        2.673400e-05       -0.0022070555
## format_16S_L6$Group12       -8.911332e-06       -0.0017649315
## format_16S_L6$Group13       -8.911332e-06       -0.0022076286
## dph                          2.825572e-07       -0.0000261044
##                       Ruminococcaceae.NK4A214.group Ruminococcaceae.UCG.002
## (Intercept)                           -3.910153e-05            1.059019e-05
## format_16S_L6$Group11                 -5.513958e-04            3.183955e-05
## format_16S_L6$Group12                 -3.472868e-04           -1.000989e-05
## format_16S_L6$Group13                 -5.700866e-04           -1.247496e-05
## dph                                    3.299777e-05            9.919822e-08
##                       Ruminococcaceae.UCG.003 Ruminococcaceae.UCG.004
## (Intercept)                      6.722515e-05            2.031215e-04
## format_16S_L6$Group11            1.311772e-04           -3.932866e-04
## format_16S_L6$Group12           -4.138415e-05           -3.051085e-04
## format_16S_L6$Group13           -4.489654e-05           -3.763944e-04
## dph                             -1.175190e-06            1.065517e-05
##                       Ruminococcaceae.UCG.005 Ruminococcaceae.UCG.008
## (Intercept)                      0.0012028296           -1.516818e-05
## format_16S_L6$Group11           -0.0041434995           -1.667233e-05
## format_16S_L6$Group12           -0.0031496281           -1.667233e-05
## format_16S_L6$Group13           -0.0040227414           -1.590011e-05
## dph                              0.0001589063            1.675816e-06
##                       Ruminococcaceae.UCG.009 Ruminococcaceae.UCG.010
## (Intercept)                      1.195009e-04            3.136283e-05
## format_16S_L6$Group11           -1.654567e-04           -3.125588e-04
## format_16S_L6$Group12           -1.720998e-04           -2.807414e-04
## format_16S_L6$Group13           -1.783114e-04           -3.146807e-04
## dph                              3.132517e-06            1.511955e-05
##                       Ruminococcaceae.UCG.013 Ruminococcaceae.UCG.014
## (Intercept)                      6.666830e-04            0.0018631347
## format_16S_L6$Group11           -5.826768e-04           -0.0043379329
## format_16S_L6$Group12           -5.981137e-04           -0.0034029244
## format_16S_L6$Group13           -6.692078e-04           -0.0043094376
## dph                              1.746224e-06            0.0001370046
##                       Ruminococcaceae.V9D2013.group Ruminococcus.1
## (Intercept)                           -3.930297e-08   8.650531e-05
## format_16S_L6$Group11                 -6.325051e-07  -2.427473e-05
## format_16S_L6$Group12                 -6.325051e-07  -2.168866e-04
## format_16S_L6$Group13                 -6.325051e-07  -2.290890e-04
## dph                                    3.535832e-08   7.919376e-06
##                       Ruminococcus.2 Subdoligranulum       UBA1819
## (Intercept)             1.663748e-04    7.533472e-04  1.312714e-05
## format_16S_L6$Group11   1.734739e-04   -1.901557e-03 -2.051447e-06
## format_16S_L6$Group12  -1.395446e-04   -1.299942e-03 -1.043679e-05
## format_16S_L6$Group13  -1.449238e-04   -2.095624e-03 -1.043679e-05
## dph                    -7.253625e-07    8.191678e-05 -1.415974e-07
##                       X.Eubacterium..coprostanoligenes.group uncultured.11
## (Intercept)                                     1.169117e-03  2.394679e-03
## format_16S_L6$Group11                          -1.379188e-03 -2.237845e-03
## format_16S_L6$Group12                          -1.320750e-03 -2.118428e-03
## format_16S_L6$Group13                          -1.439821e-03 -2.303816e-03
## dph                                             1.538922e-05 -1.609640e-06
##                              X__.32 Syntrophomonas        X__.33
## (Intercept)            0.0043077853   1.441893e-06 -3.472395e-06
## format_16S_L6$Group11 -0.0027115669   6.505165e-06 -2.700553e-05
## format_16S_L6$Group12 -0.0027670146  -2.168388e-06 -2.399509e-05
## format_16S_L6$Group13 -0.0028265412  -2.168388e-06 -2.859693e-05
## dph                   -0.0000759086   3.823659e-08  1.707363e-06
##                       uncultured.bacterium.16   Allobaculum Asteroleplasma
## (Intercept)                      1.957195e-06  2.055036e-05   2.082159e-06
## format_16S_L6$Group11           -4.921361e-05  8.318157e-06   3.319054e-06
## format_16S_L6$Group12           -4.301083e-05  4.369965e-06  -1.106351e-06
## format_16S_L6$Group13           -4.810187e-05  4.330878e-06  -1.106351e-06
## dph                              2.487180e-06 -1.858610e-07  -5.135832e-08
##                          Dubosiella Erysipelatoclostridium Erysipelothrix
## (Intercept)            4.477991e-06           0.0109616644   8.841564e-07
## format_16S_L6$Group11  1.191946e-05          -0.0063685502   1.896103e-06
## format_16S_L6$Group12 -3.553179e-06          -0.0062038241  -6.320343e-07
## format_16S_L6$Group13 -4.012660e-06          -0.0068515870  -6.320343e-07
## dph                    3.821031e-08          -0.0002035158  -1.326958e-08
##                       Erysipelotrichaceae.UCG.003  Holdemanella    Holdemania
## (Intercept)                          6.040492e-05  1.756240e-05  2.420944e-05
## format_16S_L6$Group11                8.031272e-05  3.238276e-05 -3.293550e-05
## format_16S_L6$Group12               -3.503330e-05 -1.127196e-05 -3.142673e-05
## format_16S_L6$Group13               -3.872656e-05 -9.838832e-06 -3.293550e-05
## dph                                 -6.349799e-07 -3.310754e-07  4.592664e-07
##                       Ileibacterium   Merdibacter  Turicibacter
## (Intercept)            6.386926e-05  7.549924e-05  6.201556e-06
## format_16S_L6$Group11  6.942528e-05 -1.296456e-04 -2.357282e-06
## format_16S_L6$Group12 -2.213591e-05 -7.394133e-05  6.106856e-07
## format_16S_L6$Group13 -2.364468e-05 -1.302564e-04  1.028710e-05
## dph                   -2.117083e-06  3.053820e-06  1.231024e-07
##                       X.Clostridium..innocuum.group uncultured.12
## (Intercept)                            1.074320e-04  6.380330e-04
## format_16S_L6$Group11                 -4.372286e-05 -8.600228e-04
## format_16S_L6$Group12                 -5.147451e-05 -7.682711e-04
## format_16S_L6$Group13                 -5.119333e-05 -8.675356e-04
## dph                                   -2.945130e-06  1.320339e-05
##                       uncultured.bacterium.17        X__.34
## (Intercept)                      8.628906e-05 -5.365937e-08
## format_16S_L6$Group11           -2.260282e-04 -7.272458e-08
## format_16S_L6$Group12           -2.138542e-04 -7.272458e-08
## format_16S_L6$Group13           -2.251574e-04 -7.272458e-08
## dph                              7.399878e-06  6.651787e-09
##                       Phascolarctobacterium     Dialister     Megamonas
## (Intercept)                    2.158898e-04  8.509750e-05 -0.0010459285
## format_16S_L6$Group11         -1.479214e-03  2.584063e-04 -0.0007239980
## format_16S_L6$Group12         -1.288996e-03 -8.067786e-05 -0.0013108181
## format_16S_L6$Group13         -1.876769e-03 -9.003447e-05 -0.0013216902
## dph                            9.286238e-05  2.858461e-07  0.0001251153
##                         Megasphaera      Quinella   Veillonella        X__.35
## (Intercept)           -1.230166e-07  6.326365e-06  5.075623e-05  2.572503e-06
## format_16S_L6$Group11  4.974487e-06  2.462863e-05  1.588196e-04 -1.835801e-06
## format_16S_L6$Group12 -1.717989e-06 -8.209544e-06 -5.475635e-05  1.552928e-06
## format_16S_L6$Group13 -1.717989e-06 -8.209544e-06 -5.475635e-05 -3.788300e-07
## dph                    9.689503e-08  9.911471e-08  2.105327e-07 -3.877377e-08
##                       Fusobacterium      Sneathia uncultured.bacterium.18
## (Intercept)           -1.246534e-05  8.538941e-06            4.786182e-07
## format_16S_L6$Group11  9.186588e-04 -4.173814e-06            1.332857e-06
## format_16S_L6$Group12 -3.028799e-04 -4.173814e-06           -4.442857e-07
## format_16S_L6$Group13 -3.101154e-04 -4.173814e-06           -4.442857e-07
## dph                    1.709915e-05 -2.297435e-07           -1.806975e-09
##                        Gemmatimonas uncultured.13        X__.36
## (Intercept)            1.269525e-05  4.454110e-05  1.106624e-06
## format_16S_L6$Group11  3.136067e-05  1.383106e-04  1.069417e-05
## format_16S_L6$Group12 -9.945580e-06 -4.559910e-05 -3.564725e-06
## format_16S_L6$Group13 -1.070754e-05 -4.635575e-05 -3.564725e-06
## dph                   -1.046162e-07  9.550762e-08  1.293737e-07
##                       uncultured.bacterium.19 uncultured.bacterium.20
## (Intercept)                      2.005611e-06           -4.311458e-06
## format_16S_L6$Group11            1.904366e-05            1.437977e-05
## format_16S_L6$Group12           -5.594502e-06           -4.793255e-06
## format_16S_L6$Group13           -6.724579e-06           -4.793255e-06
## dph                              2.483667e-07            4.791954e-07
##                         Victivallis uncultured.bacterium.21    Nitrospira
## (Intercept)            1.547268e-06           -4.356772e-07  1.223578e-05
## format_16S_L6$Group11 -9.073827e-06            1.847745e-06  3.755999e-05
## format_16S_L6$Group12 -6.564232e-06           -6.159150e-07 -1.252000e-05
## format_16S_L6$Group13 -9.073827e-06           -6.159150e-07 -1.252000e-05
## dph                    3.961347e-07            5.534695e-08  1.495909e-08
##                       uncultured.bacterium.22 uncultured.prokaryote.1
## (Intercept)                      1.814287e-04            6.972642e-06
## format_16S_L6$Group11            6.632390e-04            2.174106e-05
## format_16S_L6$Group12           -2.201490e-04           -7.247021e-06
## format_16S_L6$Group13           -2.215450e-04           -7.247021e-06
## dph                              2.111380e-06            1.444105e-08
##                              X__.37 uncultured.bacterium.23        X__.38
## (Intercept)            6.585328e-06            1.454955e-06  1.215718e-06
## format_16S_L6$Group11  1.616449e-05            6.174091e-06  1.497332e-06
## format_16S_L6$Group12 -5.388165e-06           -2.058030e-06 -4.991107e-07
## format_16S_L6$Group13 -5.388165e-06           -2.058030e-06 -4.991107e-07
## dph                   -6.300858e-08            3.174078e-08 -3.771617e-08
##                       uncultured.bacterium.24 uncultured.bacterium.25
## (Intercept)                      7.362786e-07            1.574647e-07
## format_16S_L6$Group11            4.360898e-06            1.873941e-06
## format_16S_L6$Group12           -1.453633e-06           -6.246469e-07
## format_16S_L6$Group13           -1.453633e-06           -6.246469e-07
## dph                              3.775547e-08            2.458853e-08
##                       Candidatus.Saccharimonas uncultured.bacterium.26
## (Intercept)                       6.614956e-07            8.894981e-07
## format_16S_L6$Group11             3.742354e-06            3.899043e-06
## format_16S_L6$Group12            -1.247451e-06           -1.299681e-06
## format_16S_L6$Group13            -1.247451e-06           -1.299681e-06
## dph                               3.083978e-08            2.158857e-08
##                              X__.39 Candidatus.Brocadia        X__.40
## (Intercept)           -1.706189e-07        1.870752e-07  3.854573e-07
## format_16S_L6$Group11  6.700705e-06        1.470151e-06  1.903438e-06
## format_16S_L6$Group12 -2.233568e-06       -4.900503e-07 -6.344794e-07
## format_16S_L6$Group13 -2.233568e-06       -4.900503e-07 -6.344794e-07
## dph                    1.265362e-07        1.594606e-08  1.310642e-08
##                       Planctomycetes.bacterium.RIFCSPHIGHO2_02_FULL_50_42
## (Intercept)                                                  8.478972e-06
## format_16S_L6$Group11                                        3.296611e-05
## format_16S_L6$Group12                                       -1.098870e-05
## format_16S_L6$Group13                                       -1.098870e-05
## dph                                                          1.320912e-07
##                       uncultured.14 uncultured.bacterium.27
## (Intercept)           -3.017973e-07            4.203026e-06
## format_16S_L6$Group11  1.564640e-05            1.525942e-05
## format_16S_L6$Group12 -5.215468e-06           -5.086473e-06
## format_16S_L6$Group13 -5.215468e-06           -5.086473e-06
## dph                    2.903824e-07            4.649724e-08
##                       uncultured.planctomycete uncultured.bacterium.28
## (Intercept)                       9.929833e-07            2.091638e-06
## format_16S_L6$Group11             2.456665e-06            2.205396e-06
## format_16S_L6$Group12            -8.188882e-07           -2.397638e-07
## format_16S_L6$Group13            -8.188882e-07           -9.828162e-07
## dph                              -9.162900e-09           -5.835904e-08
##                       Fimbriiglobus uncultured.15 Singulisphaera  Pir4.lineage
## (Intercept)           -1.021638e-06  4.506275e-06   3.307846e-07  1.360947e-06
## format_16S_L6$Group11  5.766686e-06  8.790509e-06   1.978041e-06  5.125456e-06
## format_16S_L6$Group12 -1.922229e-06 -2.930170e-06  -6.593469e-07 -1.708485e-06
## format_16S_L6$Group13 -1.922229e-06 -2.930170e-06  -6.593469e-07 -1.708485e-06
## dph                    1.549403e-07 -8.295290e-08   1.729275e-08  1.829147e-08
##                       uncultured.16 uncultured.Crater.Lake.bacterium.CL500.4
## (Intercept)            1.209209e-06                             6.503585e-07
## format_16S_L6$Group11  4.376095e-06                             1.470156e-06
## format_16S_L6$Group12 -8.246956e-07                            -4.900519e-07
## format_16S_L6$Group13 -1.775700e-06                            -4.900519e-07
## dph                    2.981531e-08                            -8.437188e-09
##                              X__.41 uncultured.17  Azospirillum   Skermanella
## (Intercept)            1.505282e-06  7.316802e-07  7.166304e-06  7.881771e-07
## format_16S_L6$Group11  4.207278e-06  1.992122e-06  2.877994e-05  1.933989e-05
## format_16S_L6$Group12 -1.402426e-06  8.982370e-07 -9.593313e-06 -6.605441e-06
## format_16S_L6$Group13 -1.402426e-06 -1.445180e-06 -9.593313e-06 -6.129011e-06
## dph                   -5.413490e-09  3.755260e-08  1.277373e-07  3.061718e-07
##                          Inquilinus uncultured.bacterium.29 Brevundimonas
## (Intercept)            1.158020e-04            3.695375e-06  7.671931e-06
## format_16S_L6$Group11  4.911181e-04            1.943901e-05  2.110772e-05
## format_16S_L6$Group12 -1.625985e-04           -6.479669e-06 -6.357582e-06
## format_16S_L6$Group13 -1.642598e-04           -6.479669e-06 -7.375069e-06
## dph                    2.550410e-06            1.465418e-07 -1.562430e-08
##                         Caulobacter Phenylobacterium uncultured.18
## (Intercept)            1.245189e-06     6.302708e-06  1.690012e-06
## format_16S_L6$Group11  6.120646e-06     2.058915e-05  2.636868e-06
## format_16S_L6$Group12 -2.040215e-06    -6.863051e-06 -8.789561e-07
## format_16S_L6$Group13 -2.040215e-06    -6.863051e-06 -8.789561e-07
## dph                    4.184351e-08     2.949177e-08 -4.268714e-08
##                              X__.42         SWB02        Dongia    Reyranella
## (Intercept)            6.924887e-06  1.838631e-06  8.236219e-06  5.159418e-06
## format_16S_L6$Group11  1.270862e-05  5.744711e-06  1.637191e-05  1.354720e-05
## format_16S_L6$Group12 -4.236207e-06 -1.914904e-06 -5.457304e-06 -4.515733e-06
## format_16S_L6$Group13 -4.236207e-06 -1.914904e-06 -5.457304e-06 -4.515733e-06
## dph                   -1.415095e-07  4.014376e-09 -1.462587e-07 -3.387819e-08
##                       uncultured.bacterium.30         Bosea Methylobacterium
## (Intercept)                      6.048854e-06  7.441418e-06     1.639454e-05
## format_16S_L6$Group11            8.667706e-06  3.608460e-05     6.226545e-05
## format_16S_L6$Group12           -2.889235e-06 -1.202820e-05    -2.016531e-05
## format_16S_L6$Group13           -2.889235e-06 -1.202820e-05    -2.105007e-05
## dph                             -1.662957e-07  2.414097e-07     2.450278e-07
##                          Microvirga       Devosia        X__.43 uncultured.19
## (Intercept)            5.890068e-06 -3.835039e-07  1.751185e-06  7.680421e-07
## format_16S_L6$Group11  1.045597e-05  1.581809e-06  4.013880e-06  8.402762e-06
## format_16S_L6$Group12 -2.532241e-06  1.106584e-06 -1.337960e-06 -2.800921e-06
## format_16S_L6$Group13 -3.961863e-06 -1.344196e-06 -1.337960e-06 -2.800921e-06
## dph                   -1.014845e-07  9.093160e-08 -2.174868e-08  1.069936e-07
##                       uncultured.20
## (Intercept)            3.647238e-06
## format_16S_L6$Group11  5.194227e-06
## format_16S_L6$Group12 -1.731409e-06
## format_16S_L6$Group13 -1.731409e-06
## dph                   -1.008331e-07
##                       Allorhizobium.Neorhizobium.Pararhizobium.Rhizobium
## (Intercept)                                                 7.321319e-06
## format_16S_L6$Group11                                       4.854062e-05
## format_16S_L6$Group12                                      -1.618021e-05
## format_16S_L6$Group13                                      -1.618021e-05
## dph                                                         4.662572e-07
##                             Ensifer Mesorhizobium Phyllobacterium        X__.44
## (Intercept)            1.313421e-06  9.388756e-06    4.259168e-05  6.343400e-06
## format_16S_L6$Group11  8.807591e-06  3.173625e-05    1.792666e-04  6.566048e-06
## format_16S_L6$Group12 -2.935864e-06 -1.057875e-05   -5.816013e-05 -2.777940e-06
## format_16S_L6$Group13 -2.935864e-06 -1.057875e-05   -5.977887e-05 -2.777940e-06
## dph                    8.539173e-08  6.263125e-08    9.861011e-07 -1.876558e-07
##                             Bauldia Bradyrhizobium  Pseudolabrys
## (Intercept)            4.834568e-06   2.587345e-05  3.957005e-06
## format_16S_L6$Group11  5.954468e-06   6.929665e-05  6.587012e-06
## format_16S_L6$Group12 -1.984823e-06  -1.961052e-05 -1.780587e-06
## format_16S_L6$Group13 -1.984823e-06  -2.413566e-05 -2.403212e-06
## dph                   -1.499866e-07  -1.699909e-08 -8.177854e-08
##                       Rhodopseudomonas      Starkeya uncultured.21
## (Intercept)               4.923600e-05  4.234643e-07  1.841120e-06
## format_16S_L6$Group11     2.051417e-04  5.833130e-06  1.193728e-05
## format_16S_L6$Group12    -6.838058e-05 -1.944377e-06 -3.979093e-06
## format_16S_L6$Group13    -6.838058e-05 -1.944377e-06 -3.979093e-06
## dph                       1.007609e-06  8.004803e-08  1.125249e-07
##                       uncultured.bacterium.31        X__.45   Gemmobacter
## (Intercept)                      5.980049e-07  1.694152e-06 -6.239457e-07
## format_16S_L6$Group11            4.560553e-06  2.259656e-06  6.042144e-06
## format_16S_L6$Group12           -1.520184e-06 -1.577867e-06 -2.014048e-06
## format_16S_L6$Group13           -1.520184e-06 -1.577867e-06 -2.014048e-06
## dph                              4.853576e-08 -6.120274e-09  1.388418e-07
##                         Rhodobacter Rubellimicrobium        X__.46
## (Intercept)           -2.437212e-07     9.984118e-06  4.709030e-07
## format_16S_L6$Group11  1.049110e-06     4.360515e-05  3.945933e-06
## format_16S_L6$Group12 -3.497033e-07    -1.518796e-05 -1.315311e-06
## format_16S_L6$Group13 -3.497033e-07    -1.518796e-05 -1.315311e-06
## dph                    3.123287e-08     2.738863e-07  4.444252e-08
##                       Azospirillum.sp..47_25 gut.metagenome.2
## (Intercept)                     1.169083e-04    -2.111476e-05
## format_16S_L6$Group11          -1.535304e-04    -2.815467e-04
## format_16S_L6$Group12          -1.858459e-04    -2.160344e-04
## format_16S_L6$Group13          -1.967094e-04    -3.075742e-04
## dph                             4.274763e-06     1.811862e-05
##                       unidentified.rumen.bacterium.RF32 uncultured.bacterium.32
## (Intercept)                                7.555371e-05            1.533890e-05
## format_16S_L6$Group11                     -2.279437e-04           -7.440755e-06
## format_16S_L6$Group12                     -1.873204e-04           -3.411810e-06
## format_16S_L6$Group13                     -2.265438e-04            2.171453e-05
## dph                                        8.368659e-06           -2.356285e-07
##                       Novosphingobium   Sphingobium  Sphingomonas  Sphingopyxis
## (Intercept)             -2.699548e-07  3.660391e-04  3.905000e-06  2.913863e-06
## format_16S_L6$Group11    1.031372e-06  1.471775e-03  1.050023e-05  5.912114e-06
## format_16S_L6$Group12   -4.281565e-07 -4.878708e-04 -4.323226e-06 -1.970705e-06
## format_16S_L6$Group13   -1.750586e-07 -4.915518e-04 -1.853780e-06 -1.970705e-06
## dph                      3.674270e-08  6.648062e-06  2.201191e-08 -4.963992e-08
##                       uncultured.22        X__.47 Candidatus.Alysiosphaera
## (Intercept)            3.820030e-06  6.462908e-06            -3.463786e-07
## format_16S_L6$Group11  1.364381e-05  1.167017e-05            -6.517171e-07
## format_16S_L6$Group12 -4.547937e-06 -3.890055e-06            -6.517171e-07
## format_16S_L6$Group13 -4.547937e-06 -3.890055e-06            -6.517171e-07
## dph                    3.831089e-08 -1.354133e-07             5.253135e-08
##                       uncultured.23 uncultured.bacterium.33        X__.48
## (Intercept)           -9.546605e-08            2.676151e-06  6.455639e-07
## format_16S_L6$Group11  4.403582e-07            1.016019e-05  1.285789e-06
## format_16S_L6$Group12  1.205003e-07           -3.386729e-06  7.488576e-07
## format_16S_L6$Group13 -2.804293e-07           -3.386729e-06 -1.017323e-06
## dph                    1.978396e-08            3.739883e-08  1.956629e-08
##                        Peredibacter  Bdellovibrio uncultured.24     Bilophila
## (Intercept)            1.627816e-06  2.644745e-05  2.025025e-08  3.554873e-04
## format_16S_L6$Group11  6.427651e-06  6.190820e-05  2.529141e-06 -1.021645e-03
## format_16S_L6$Group12 -2.142550e-06 -2.063607e-05 -8.430470e-07 -9.443015e-04
## format_16S_L6$Group13 -2.142550e-06 -2.063607e-05 -8.430470e-07 -1.060208e-03
## dph                    2.709131e-08 -3.058623e-07  4.330509e-08  4.330593e-05
##                       Desulfovibrio uncultured.25        X__.49
## (Intercept)            5.274450e-06  1.500179e-04 -1.321076e-05
## format_16S_L6$Group11  2.042316e-05  1.424834e-04 -2.775867e-05
## format_16S_L6$Group12 -6.807719e-06 -2.202854e-04 -2.000238e-05
## format_16S_L6$Group13 -6.807719e-06 -2.528003e-04 -2.500834e-05
## dph                    8.069835e-08  6.499015e-06  2.156285e-06
##                       uncultured.bacterium.34   Cystobacter        X__.50
## (Intercept)                      2.161873e-06  1.639544e-06  6.019832e-07
## format_16S_L6$Group11            5.272110e-06  3.214123e-06  1.012016e-06
## format_16S_L6$Group12           -1.757370e-06 -1.071374e-06 -3.373388e-07
## format_16S_L6$Group13           -1.757370e-06 -1.071374e-06 -3.373388e-07
## dph                             -2.128962e-08 -2.990365e-08 -1.392865e-08
##                       uncultured.soil.bacterium    Haliangium
## (Intercept)                       -5.508330e-07  8.240065e-07
## format_16S_L6$Group11              1.375350e-06  7.177693e-06
## format_16S_L6$Group12             -4.584501e-07 -2.392564e-06
## format_16S_L6$Group13             -4.584501e-07 -2.392564e-06
## dph                                5.312017e-08  8.255567e-08
##                       uncultured.delta.proteobacterium uncultured.26
## (Intercept)                               1.412211e-06  1.851449e-06
## format_16S_L6$Group11                     4.369254e-06  2.764609e-06
## format_16S_L6$Group12                    -1.456418e-06 -9.215364e-07
## format_16S_L6$Group13                    -1.456418e-06 -9.215364e-07
## dph                                       2.326680e-09 -4.894279e-08
##                       Deltaproteobacteria.bacterium.GWD2_55_8
## (Intercept)                                      1.692139e-06
## format_16S_L6$Group11                            3.988804e-06
## format_16S_L6$Group12                           -1.329601e-06
## format_16S_L6$Group13                           -1.329601e-06
## dph                                             -1.908094e-08
##                       uncultured.Myxococcales.bacterium uncultured.bacterium.35
## (Intercept)                                1.781953e-07            2.920850e-06
## format_16S_L6$Group11                      3.919635e-06            1.232727e-05
## format_16S_L6$Group12                     -1.306545e-06           -4.109089e-06
## format_16S_L6$Group13                     -1.306545e-06           -4.109089e-06
## dph                                        5.938683e-08            6.253892e-08
##                       uncultured.soil.bacterium.1        X__.51
## (Intercept)                         -8.710392e-07  1.561082e-06
## format_16S_L6$Group11                5.308017e-06  5.600606e-06
## format_16S_L6$Group12               -1.769339e-06 -1.866869e-06
## format_16S_L6$Group13               -1.769339e-06 -1.866869e-06
## dph                                  1.389673e-07  1.609403e-08
##                       uncultured.bacterium.36        X__.52       RCP1.48
## (Intercept)                      2.132263e-06  7.974708e-06 -4.395654e-07
## format_16S_L6$Group11            5.136762e-06  1.941143e-05 -4.211278e-07
## format_16S_L6$Group12           -1.712254e-06 -6.470476e-06  1.263383e-06
## format_16S_L6$Group13           -1.712254e-06 -6.470476e-06 -4.211278e-07
## dph                             -2.210572e-08 -7.917011e-08  4.529964e-08
##                       uncultured.27  Marinobacter
## (Intercept)            9.761696e-07  1.323913e-06
## format_16S_L6$Group11  8.268254e-06  2.025873e-05
## format_16S_L6$Group12 -2.756085e-06 -6.752909e-06
## format_16S_L6$Group13 -2.756085e-06 -6.752909e-06
## dph                    9.367974e-08  2.857366e-07
##                       uncultured.Rhodocyclaceae.bacterium    Acidovorax
## (Intercept)                                  1.565759e-07  9.755825e-06
## format_16S_L6$Group11                        1.769882e-06  2.574183e-05
## format_16S_L6$Group12                       -5.899606e-07 -8.580610e-06
## format_16S_L6$Group13                       -5.899606e-07 -8.580610e-06
## dph                                          2.280972e-08 -6.185342e-08
##                           Comamonas   Cupriavidus   Curvibacter       Delftia
## (Intercept)            1.722319e-06  2.361491e-05  1.998690e-04  6.929527e-05
## format_16S_L6$Group11  1.444647e-06  1.179969e-04  5.057516e-04 -2.844904e-05
## format_16S_L6$Group12  9.884051e-07 -3.933232e-05 -9.859309e-05  8.534712e-05
## format_16S_L6$Group13 -1.216526e-06 -3.933232e-05 -1.920986e-04 -2.844904e-05
## dph                   -2.662069e-08  8.272317e-07  8.325433e-07 -2.149801e-06
##                           Lautropia   Limnobacter      Massilia Parasutterella
## (Intercept)            4.265261e-07 -4.028647e-07  5.163192e-06   3.431010e-04
## format_16S_L6$Group11 -2.599455e-07  2.273990e-06  1.076779e-05   7.881058e-04
## format_16S_L6$Group12 -2.599455e-07 -7.579966e-07 -3.589262e-06  -2.651005e-04
## format_16S_L6$Group13 -2.599455e-07 -7.579966e-07 -3.589262e-06  -2.703089e-04
## dph                   -8.767400e-09  6.109796e-08 -8.283840e-08  -3.536244e-06
##                           Pelomonas   Polaromonas Polynucleobacter
## (Intercept)            4.539718e-07  8.273927e-06     5.590857e-06
## format_16S_L6$Group11  3.686939e-06  2.913644e-05    -3.653228e-06
## format_16S_L6$Group12 -1.228980e-06 -9.712147e-06    -3.653228e-06
## format_16S_L6$Group13 -1.228980e-06 -9.712147e-06     1.095968e-05
## dph                    4.078989e-08  7.569581e-08    -1.019805e-07
##                           Ralstonia  Sphaerotilus    Sutterella Undibacterium
## (Intercept)            4.201817e-06  9.989832e-07  2.365565e-05  1.105595e-05
## format_16S_L6$Group11  1.415762e-05  1.686649e-06  1.019809e-04  4.726124e-05
## format_16S_L6$Group12 -4.537850e-06 -5.622162e-07 -2.813528e-05 -1.575375e-05
## format_16S_L6$Group13 -4.631187e-06 -5.622162e-07 -3.827056e-05 -1.575375e-05
## dph                    4.140881e-08 -2.298773e-08  8.004133e-07  2.472526e-07
##                          Variovorax        X__.53     Vogesella   Gallionella
## (Intercept)            1.538414e-04  2.303369e-05  2.201844e-05  4.026466e-05
## format_16S_L6$Group11  5.786034e-04  3.931771e-05  1.222297e-05  1.253412e-04
## format_16S_L6$Group12 -1.924260e-04 -1.116988e-05  3.560990e-06 -3.963996e-05
## format_16S_L6$Group13 -1.930887e-04 -7.006748e-06 -3.911756e-06 -4.285060e-05
## dph                    2.065647e-06 -9.961080e-08 -5.340121e-07  1.361023e-07
##                              X__.54 uncultured.28           MM2 Methylobacillus
## (Intercept)            6.815316e-06  9.955109e-07 -3.880507e-07    2.220366e-06
## format_16S_L6$Group11  1.237210e-05  3.631748e-06  2.901429e-06    7.115351e-06
## format_16S_L6$Group12 -2.635040e-06 -1.210583e-06 -9.671428e-07   -2.371784e-06
## format_16S_L6$Group13 -4.868529e-06 -1.210583e-06 -9.671428e-07   -2.371784e-06
## dph                   -1.024625e-07  1.131957e-08  7.132598e-08    7.969323e-09
##                       Methylophilus Methylotenera     Neisseria uncultured.29
## (Intercept)            4.598429e-07  1.394784e-06  6.478536e-07  2.141436e-07
## format_16S_L6$Group11  9.330033e-07  2.410420e-05 -3.015215e-07  4.637182e-06
## format_16S_L6$Group12 -3.110011e-07 -7.922923e-06 -3.015215e-07 -1.545727e-06
## format_16S_L6$Group13 -3.110011e-07 -8.447723e-06 -3.015215e-07 -1.545727e-06
## dph                   -7.833781e-09  3.712073e-07 -1.822800e-08  7.008335e-08
##                                MND1 Methyloversatilis  Sulfuritalea
## (Intercept)           -9.222924e-07      2.687816e-07  1.840245e-05
## format_16S_L6$Group11  4.507866e-06      4.732848e-07  3.329954e-05
## format_16S_L6$Group12 -1.502622e-06     -1.577616e-07 -7.429285e-06
## format_16S_L6$Group13 -1.502622e-06     -1.577616e-07 -1.236931e-05
## dph                    1.276271e-07     -5.843156e-09 -2.579741e-07
##                       uncultured.30        X__.55 Ferritrophicum        X__.56
## (Intercept)            3.158443e-06  3.191132e-07   3.392743e-06  4.421060e-06
## format_16S_L6$Group11  6.472156e-06  2.497428e-06   1.263089e-05  1.268005e-05
## format_16S_L6$Group12 -2.157385e-06 -8.324760e-07  -4.210297e-06 -4.297870e-06
## format_16S_L6$Group13 -2.157385e-06 -8.324760e-07  -4.210297e-06 -4.084308e-06
## dph                   -5.268723e-08  2.701910e-08   4.302915e-08 -6.483671e-09
##                              X__.57     Aquicella  Enterobacter
## (Intercept)           -1.567489e-07  1.206293e-06  2.268837e-05
## format_16S_L6$Group11  1.917440e-06  1.954575e-06  8.087147e-05
## format_16S_L6$Group12 -6.391466e-07 -6.515251e-07 -3.140885e-05
## format_16S_L6$Group13 -6.391466e-07 -6.515251e-07 -3.354488e-05
## dph                    4.188924e-08 -2.919829e-08  7.077423e-07
##                       Escherichia.Shigella    Klebsiella    Morganella
## (Intercept)                    0.154244191  0.0054660805  1.675413e-05
## format_16S_L6$Group11          0.006072128 -0.0009406350  5.297771e-05
## format_16S_L6$Group12         -0.020197674 -0.0020465351 -1.765924e-05
## format_16S_L6$Group13         -0.026596543 -0.0020361678 -1.765924e-05
## dph                           -0.004947990 -0.0001712284  4.763736e-08
##                             Proteus    Salmonella        X__.58 Methylobacter
## (Intercept)            1.115264e-04  9.364456e-05  1.249133e-03 -4.311019e-07
## format_16S_L6$Group11  2.073684e-04  1.496614e-04 -1.671092e-04  3.074339e-06
## format_16S_L6$Group12 -3.430287e-05 -5.444475e-05 -4.055515e-04 -1.024780e-06
## format_16S_L6$Group13 -9.768462e-05 -4.077186e-05 -4.764045e-04 -1.024780e-06
## dph                   -6.532744e-07 -2.063148e-06 -3.917774e-05  7.662535e-08
##                       uncultured.31        X__.59        X__.60        X__.61
## (Intercept)            9.996406e-06  3.770082e-06  1.323408e-06  1.230637e-06
## format_16S_L6$Group11  5.129740e-05  2.291896e-05  2.883656e-06  4.141370e-06
## format_16S_L6$Group12 -1.709913e-05 -7.639653e-06 -9.612187e-07 -1.380457e-06
## format_16S_L6$Group13 -1.709913e-05 -7.639653e-06 -9.612187e-07 -1.380457e-06
## dph                    3.738278e-07  2.036616e-07 -1.906258e-08  7.885227e-09
##                         Haemophilus    Muribacter Rodentibacter        X__.62
## (Intercept)            1.022759e-04  4.638310e-05  6.259977e-04  8.602200e-06
## format_16S_L6$Group11  2.339865e-04  1.502113e-04  1.776850e-03  2.577495e-05
## format_16S_L6$Group12 -8.715737e-05 -4.765025e-05 -5.902295e-04 -8.591650e-06
## format_16S_L6$Group13 -8.898891e-05 -5.128051e-05 -5.902128e-04 -8.591650e-06
## dph                   -6.679631e-07  2.577585e-07 -1.557368e-06 -5.552385e-10
##                       Acinetobacter Enhydrobacter     Moraxella   Pseudomonas
## (Intercept)            2.419407e-04  7.049560e-06  8.305489e-06  7.353505e-04
## format_16S_L6$Group11  6.921610e-04  1.480686e-05  4.258014e-04  2.304031e-03
## format_16S_L6$Group12 -2.091937e-04 -1.680743e-06 -1.437760e-04 -7.573719e-04
## format_16S_L6$Group13 -2.428480e-04 -6.779742e-06 -1.467875e-04 -7.647290e-04
## dph                    5.230417e-07 -1.420091e-08  7.288526e-06  2.451585e-06
##                             Woeseia        Vibrio uncultured.32    Luteimonas
## (Intercept)            7.358377e-07  8.174114e-07  7.145767e-07  2.847414e-05
## format_16S_L6$Group11  9.593857e-06 -2.840138e-06  2.598989e-06  2.913389e-05
## format_16S_L6$Group12 -3.197952e-06 -2.840138e-06 -8.663298e-07 -8.436116e-06
## format_16S_L6$Group13 -3.197952e-06 -2.840138e-06 -8.663298e-07 -1.024058e-05
## dph                    1.295850e-07  1.064593e-07  7.987004e-09 -9.482600e-07
##                          Lysobacter Pseudoxanthomonas Stenotrophomonas
## (Intercept)            2.913892e-06      4.159412e-05     1.248384e-05
## format_16S_L6$Group11  1.376436e-05      1.342820e-04     4.182744e-05
## format_16S_L6$Group12 -4.588122e-06     -4.454197e-05    -1.394248e-05
## format_16S_L6$Group13 -4.588122e-06     -4.487001e-05    -1.394248e-05
## dph                    8.811736e-08      1.724151e-07     7.677074e-08
##                         Xanthomonas        X__.63        X__.64 Sh765B.TzT.35
## (Intercept)            4.107623e-06  7.827087e-06  3.975574e-06  1.631928e-06
## format_16S_L6$Group11  2.080323e-05  2.132579e-05  1.551164e-05  6.602696e-06
## format_16S_L6$Group12 -6.934412e-06 -7.108596e-06 -5.170547e-06 -2.200899e-06
## format_16S_L6$Group13 -6.934412e-06 -7.108596e-06 -5.170547e-06 -2.200899e-06
## dph                    1.487783e-07 -3.781531e-08  6.289334e-08  2.994583e-08
##                       uncultured.bacterium.37 uncultured.proteobacterium
## (Intercept)                      6.138909e-06               2.700626e-07
## format_16S_L6$Group11            1.671191e-05               6.115006e-06
## format_16S_L6$Group12           -5.570637e-06              -2.038335e-06
## format_16S_L6$Group13           -5.570637e-06              -2.038335e-06
## dph                             -2.990908e-08               9.306698e-08
##                       uncultured.soil.bacterium.2        X__.65  Anaeroplasma
## (Intercept)                          4.591628e-07  5.075592e-06  2.007045e-03
## format_16S_L6$Group11                4.721802e-06  1.180282e-05 -7.215201e-04
## format_16S_L6$Group12               -1.573934e-06 -3.934273e-06 -9.577536e-04
## format_16S_L6$Group13               -1.573934e-06 -3.934273e-06 -8.904510e-04
## dph                                  5.867218e-08 -6.006946e-08 -5.502032e-05
##                       uncultured.bacterium.38 uncultured.organism.2
## (Intercept)                     -3.897578e-07         -1.617345e-06
## format_16S_L6$Group11            2.200007e-06         -1.787708e-05
## format_16S_L6$Group12           -7.333358e-07         -1.333772e-05
## format_16S_L6$Group13           -7.333358e-07         -1.728142e-05
## dph                              5.911019e-08          1.026023e-06
##                       gut.metagenome.3 uncultured.bacterium.39
## (Intercept)               1.179224e-05            1.257973e-04
## format_16S_L6$Group11    -7.776511e-06           -1.510051e-04
## format_16S_L6$Group12    -7.776511e-06           -1.573167e-04
## format_16S_L6$Group13    -7.776511e-06           -1.615085e-04
## dph                      -2.113543e-07            1.879540e-06
##                       uncultured.rumen.bacterium.2        X__.66    Mycoplasma
## (Intercept)                           5.052664e-08  1.389420e-05 -5.130696e-06
## format_16S_L6$Group11                -3.647105e-07 -3.862974e-05  3.278184e-05
## format_16S_L6$Group12                -3.647105e-07 -3.752024e-05 -1.092728e-05
## format_16S_L6$Group13                -3.647105e-07 -3.862974e-05 -1.092728e-05
## dph                                   1.653599e-08  1.301871e-06  8.451567e-07
##                       Chthoniobacter Candidatus.Xiphinematobacter uncultured.33
## (Intercept)             4.501337e-06                 5.470928e-06 -2.503802e-06
## format_16S_L6$Group11   7.716161e-06                 8.712641e-06 -3.015005e-06
## format_16S_L6$Group12  -2.572054e-06                -2.904214e-06 -3.015005e-06
## format_16S_L6$Group13  -2.572054e-06                -2.904214e-06 -3.015005e-06
## dph                    -1.015412e-07                -1.350902e-07  2.904635e-07
##                              X__.67   Akkermansia uncultured.bacterium.40
## (Intercept)            1.170527e-06  1.272524e-04           -5.091152e-07
## format_16S_L6$Group11  2.461360e-06 -5.161616e-04            2.495001e-06
## format_16S_L6$Group12 -8.204532e-07 -1.232838e-03           -8.316671e-07
## format_16S_L6$Group13 -8.204532e-07 -1.288364e-03           -8.316671e-07
## dph                   -1.842493e-08  6.245402e-05            7.056749e-08
## 
## $coef.sites
##                            D01E01C       D01E01D      D01E01I      D01E01J
## (Intercept)            0.768319379  0.7280066081  0.738594936  0.718380438
## format_16S_L6$Group11 -0.004687987 -0.0063450944  0.012891662  0.001688872
## format_16S_L6$Group12  0.028682654  0.0212555725 -0.002292813  0.006263610
## format_16S_L6$Group13  0.013332631  0.0001379295 -0.029688036 -0.014392984
## dph                    0.006801556  0.0080119585  0.007777279  0.008451640
##                            D01E02C      D01E02D       D01E02I      D01E02J
## (Intercept)            0.808898659  0.770328138  0.7543416761  0.709227519
## format_16S_L6$Group11 -0.009053748 -0.017803142 -0.0140153133 -0.002087100
## format_16S_L6$Group12  0.025642818  0.031258164  0.0330129401  0.009938049
## format_16S_L6$Group13  0.024327045  0.009900662 -0.0005581467 -0.018317470
## dph                    0.005657481  0.006569076  0.0071799953  0.008649860
##                            D01E03C       D01E03D      D01E03I      D01E03J
## (Intercept)            0.744485466  0.7142186302  0.789679576  0.726913637
## format_16S_L6$Group11 -0.003494438  0.0003466728  0.013423799  0.009537464
## format_16S_L6$Group12  0.024624347  0.0067290232 -0.004331589 -0.001627849
## format_16S_L6$Group13  0.006414955 -0.0140938381 -0.039705618 -0.024760035
## dph                    0.007592228  0.0084799444  0.006117160  0.008146730
##                           D01E04C      D01E04D       D01E04I      D01E04J
## (Intercept)            0.77995609  0.709631935  7.421831e-01  0.778230244
## format_16S_L6$Group11 -0.01524456 -0.002137416  1.093891e-02  0.014500230
## format_16S_L6$Group12  0.03166137  0.009354421 -6.965353e-05 -0.003812405
## format_16S_L6$Group13  0.01371423 -0.016006142 -3.588156e-02 -0.037878810
## dph                    0.00649183  0.008622619  7.594762e-03  0.006500895
##                            D01E05C      D01E05D       D01E05I      D01E05J
## (Intercept)            0.799179718  0.809972696  0.7854993132  0.788226074
## format_16S_L6$Group11 -0.013066571 -0.011894543 -0.0207599527 -0.015193659
## format_16S_L6$Group12  0.027230681  0.022122143  0.0319481265  0.028430991
## format_16S_L6$Group13  0.020798433  0.029235621 -0.0003125864  0.015513558
## dph                    0.005996122  0.005322698  0.0062889544  0.006281513
##                            D01E06C     D01E06D       D01E06I       D01E06J
## (Intercept)            0.859167728 0.779987635  0.7328188867  0.7266809870
## format_16S_L6$Group11 -0.005249117 0.016028377  0.0105114717  0.0091268190
## format_16S_L6$Group12  0.016540856 0.026399981 -0.0002892916 -0.0009501393
## format_16S_L6$Group13  0.018764788 0.024661939 -0.0303955262 -0.0243385523
## dph                    0.004049737 0.004548287  0.0078983414  0.0081398153
##                            D01E07C      D01E07D      D01E07I      D01E07J
## (Intercept)            0.769593226  0.716625553  0.720366688  0.719549769
## format_16S_L6$Group11 -0.001840513 -0.004799865  0.001641966  0.004396372
## format_16S_L6$Group12  0.026652872  0.016426827  0.007854879  0.002772511
## format_16S_L6$Group13  0.013284290 -0.006626432 -0.013603563 -0.017631188
## dph                    0.006819731  0.008389370  0.008417684  0.008399536
##                            D01E08C       D01E08D      D01E08I      D01E08J
## (Intercept)            0.708785045  0.7284407928  0.749036073  0.741383088
## format_16S_L6$Group11 -0.003562206 -0.0050813548  0.014439151  0.013243414
## format_16S_L6$Group12  0.012448414  0.0204964393 -0.002551649 -0.002261495
## format_16S_L6$Group13 -0.016794557 -0.0009470518 -0.032991456 -0.031831856
## dph                    0.008649261  0.0080556705  0.007455882  0.007618375
##                            D01E09C       D01E09D      D01E09I       D01E09J
## (Intercept)            0.744522153  0.7082989445  0.751313604  0.7234836466
## format_16S_L6$Group11 -0.003105050  0.0005635225  0.014089295  0.0073697952
## format_16S_L6$Group12  0.022908531  0.0047366889 -0.002202607 -0.0003713761
## format_16S_L6$Group13  0.002545896 -0.0077347266 -0.034456934 -0.0227289038
## dph                    0.007566330  0.0081666293  0.007374639  0.0082383000
##                            D01E10C       D01E10D      D01E10I      D01E10J
## (Intercept)            0.764833911  0.7170159300  0.788546218  0.736376030
## format_16S_L6$Group11 -0.001539006  0.0001441369  0.015190026  0.012381241
## format_16S_L6$Group12  0.028111439  0.0085017095 -0.004367978 -0.002414046
## format_16S_L6$Group13  0.013638772 -0.0099808428 -0.039181858 -0.027718477
## dph                    0.006955610  0.0083229935  0.006198398  0.007883541
##                             D04E01C     D04E01D      D04E01I      D04E01J
## (Intercept)            7.195746e-01  0.62479799  0.570725138  0.587067194
## format_16S_L6$Group11  9.770847e-03 -0.11205605 -0.086523731 -0.080681098
## format_16S_L6$Group12  1.100448e-02 -0.11459235 -0.178631121 -0.180128366
## format_16S_L6$Group13  1.872546e-02 -0.10616138 -0.145750528 -0.117124620
## dph                   -9.690618e-05 -0.00318258 -0.004296423 -0.005119618
##                           D04E02C      D04E02D      D04E02I      D04E02J
## (Intercept)           0.795893292  0.593112986  0.674985298  0.599899227
## format_16S_L6$Group11 0.074255018 -0.113440580 -0.028458315 -0.074997608
## format_16S_L6$Group12 0.063795122 -0.144026569 -0.048374080 -0.141913706
## format_16S_L6$Group13 0.063481232 -0.091782183 -0.084555017 -0.081086331
## dph                   0.002640342 -0.005028054  0.002265367 -0.004810156
##                           D04E03C      D04E03D      D04E03I     D04E03J
## (Intercept)           0.763610625  0.609908262  0.628122345  0.58355848
## format_16S_L6$Group11 0.050573836 -0.078410468 -0.047917411 -0.05419823
## format_16S_L6$Group12 0.048897396 -0.074020098 -0.070388281 -0.13931082
## format_16S_L6$Group13 0.055827304 -0.044460837 -0.103378512 -0.09209025
## dph                   0.002933169 -0.003403429  0.001708565 -0.00403182
##                           D04E04C      D04E04D      D04E04I      D04E04J
## (Intercept)           0.753015715  0.639042949  0.583108519  0.678237751
## format_16S_L6$Group11 0.053214243 -0.105167696 -0.089718242 -0.052262694
## format_16S_L6$Group12 0.054193379 -0.057947653 -0.191849470 -0.120497141
## format_16S_L6$Group13 0.060330014 -0.063672315 -0.144247597 -0.097078257
## dph                   0.002989243 -0.001533105 -0.005144383 -0.002983927
##                           D04E05C       D04E05D      D04E05I     D04E05J
## (Intercept)           0.767082333  0.7666638589  0.672549621  0.60260140
## format_16S_L6$Group11 0.052604680 -0.0761268202 -0.089634164 -0.08462020
## format_16S_L6$Group12 0.058175639 -0.0096787124 -0.083752087 -0.16222762
## format_16S_L6$Group13 0.063261628 -0.0369140903 -0.105122780 -0.12087781
## dph                   0.002219211  0.0002323057 -0.001808232 -0.00431972
##                           D04E06C     D04E06D     D04E06I      D04E06J
## (Intercept)           0.773227332  0.58794116  0.61139372  0.589648109
## format_16S_L6$Group11 0.055750858 -0.10731073 -0.09651010 -0.090129367
## format_16S_L6$Group12 0.057230274 -0.19088415 -0.13030576 -0.185961747
## format_16S_L6$Group13 0.065266647 -0.12878747 -0.13004178 -0.133412131
## dph                   0.001884392 -0.00558389 -0.00303749 -0.005010221
##                           D04E07C      D04E07D      D04E07I      D04E07J
## (Intercept)           0.798601047  0.590526046  0.575875974  0.602286386
## format_16S_L6$Group11 0.057981497 -0.096431387 -0.081561059 -0.077690457
## format_16S_L6$Group12 0.055125179 -0.196542683 -0.181024039 -0.213181874
## format_16S_L6$Group13 0.069057490 -0.114044038 -0.145819359 -0.126563966
## dph                   0.001201803 -0.006313959 -0.004399686 -0.006390255
##                           D04E08C      D04E08D      D04E08I     D04E08J
## (Intercept)           0.702415694  0.583801634  0.589480757  0.59233740
## format_16S_L6$Group11 0.037332691 -0.108816763 -0.066545362 -0.06945715
## format_16S_L6$Group12 0.038328132 -0.174462694 -0.175281311 -0.21273079
## format_16S_L6$Group13 0.049595393 -0.107545085 -0.109670247 -0.11399770
## dph                   0.002665534 -0.005712419 -0.005261861 -0.00659345
##                           D04E09C      D04E09D       D04E09I      D04E09J
## (Intercept)           0.752710951  0.672605110  0.7517746980  0.595429457
## format_16S_L6$Group11 0.054272153 -0.107918495 -0.0630864260 -0.072152926
## format_16S_L6$Group12 0.054184461 -0.072100684 -0.0392185382 -0.220540945
## format_16S_L6$Group13 0.060748944 -0.088497927 -0.0758841718 -0.125635974
## dph                   0.002347762 -0.001880356 -0.0003408573 -0.006663219
##                            D04E10C       D04E10D       D04E10I       D04E10J
## (Intercept)           0.7185054003  0.7049820633  0.7221843939  8.634871e-01
## format_16S_L6$Group11 0.0226688269 -0.0920148997 -0.0426921908  3.049809e-02
## format_16S_L6$Group12 0.0184001547 -0.0386242390 -0.0487471416 -3.282431e-02
## format_16S_L6$Group13 0.0347781115 -0.0609883485 -0.0776285461 -7.745418e-05
## dph                   0.0001954732 -0.0006735637 -0.0002270169  1.788336e-04
##                             D07E01C      D07E01D      D07E01I      D07E01J
## (Intercept)            0.8116879529  0.588778081  0.602600289  0.599261923
## format_16S_L6$Group11  0.0601161201 -0.108028411 -0.074722128 -0.068261697
## format_16S_L6$Group12  0.0455279929 -0.181181895 -0.214524718 -0.208686346
## format_16S_L6$Group13  0.0675434890 -0.113492931 -0.143313437 -0.128373145
## dph                   -0.0005070304 -0.005820271 -0.006424098 -0.006322594
##                             D07E02C      D07E02D      D07E02I      D07E02J
## (Intercept)            0.8197474489  0.632490313  0.623799873  0.603133191
## format_16S_L6$Group11  0.0662006735 -0.118280165 -0.072112306 -0.060722025
## format_16S_L6$Group12  0.0538815577 -0.083818109 -0.169505322 -0.195288802
## format_16S_L6$Group13  0.0793152805 -0.080781645 -0.146587658 -0.121236852
## dph                   -0.0003377904 -0.002690567 -0.004959199 -0.006130793
##                            D07E03C      D07E03D      D07E03I       D07E03J
## (Intercept)           8.361093e-01  0.593157384  0.592199505  0.8329836578
## format_16S_L6$Group11 8.853410e-02 -0.107885444 -0.089448261  0.0028578839
## format_16S_L6$Group12 6.751883e-02 -0.194743276 -0.170710805 -0.0508827425
## format_16S_L6$Group13 9.778433e-02 -0.131285644 -0.139597127 -0.0353553511
## dph                   1.864122e-05 -0.005786624 -0.004560018 -0.0003990257
##                             D07E04C      D07E04D      D07E04I      D07E04J
## (Intercept)            0.7787219955  0.592937748  0.597887111  0.696670848
## format_16S_L6$Group11  0.0374195314 -0.102641943 -0.083108922 -0.055500927
## format_16S_L6$Group12  0.0280670741 -0.192475270 -0.189497108 -0.116959253
## format_16S_L6$Group13  0.0474219223 -0.135022827 -0.149200195 -0.105610177
## dph                   -0.0005834967 -0.005473101 -0.005166704 -0.002883709
##                            D07E05C      D07E05D      D07E05I      D07E05J
## (Intercept)           8.222667e-01  0.601320940  0.623582399  0.718082759
## format_16S_L6$Group11 6.152419e-02 -0.093235960 -0.049409833 -0.026234141
## format_16S_L6$Group12 5.289617e-02 -0.208749238 -0.131989656 -0.096523293
## format_16S_L6$Group13 7.718107e-02 -0.126482281 -0.082913076 -0.071878736
## dph                   5.714743e-05 -0.006634169 -0.004919906 -0.002477454
##                             D07E06C      D07E06D      D07E06I      D07E06J
## (Intercept)            0.8606882669  0.599195893  0.611156939  0.609465526
## format_16S_L6$Group11  0.0617817074 -0.105310756 -0.079576154 -0.073536380
## format_16S_L6$Group12  0.0488701223 -0.203404008 -0.219686620 -0.224075159
## format_16S_L6$Group13  0.0734916050 -0.130109100 -0.143839012 -0.138446628
## dph                   -0.0003430719 -0.006336737 -0.006647014 -0.006850316
##                            D07E07C     D07E07D      D07E07I      D07E07J
## (Intercept)            0.812043302  0.59807592  0.597973270  0.595324430
## format_16S_L6$Group11  0.093598965 -0.10187523 -0.075905174 -0.065062714
## format_16S_L6$Group12  0.076143567 -0.20536657 -0.214150956 -0.204470368
## format_16S_L6$Group13  0.119413587 -0.12612491 -0.137322466 -0.106371067
## dph                   -0.001946503 -0.00648315 -0.006447106 -0.006722386
##                             D07E08C      D07E08D      D07E08I      D07E08J
## (Intercept)            0.7819611855  0.610757349  0.598216130  0.606254020
## format_16S_L6$Group11  0.0539697038 -0.089938614 -0.088204185 -0.074366924
## format_16S_L6$Group12  0.0448525093 -0.215163929 -0.201203876 -0.223906794
## format_16S_L6$Group13  0.0681876469 -0.138115579 -0.146206248 -0.136152868
## dph                   -0.0003499092 -0.006690746 -0.005517734 -0.006784487
##                            D07E09C      D07E09D      D07E09I      D07E09J
## (Intercept)            0.790585589  0.608937531  0.610851731  0.612466408
## format_16S_L6$Group11  0.062161905 -0.090738866 -0.079366611 -0.077757500
## format_16S_L6$Group12  0.050946264 -0.214487979 -0.218492618 -0.221118663
## format_16S_L6$Group13  0.080323683 -0.136542042 -0.145914603 -0.142224718
## dph                   -0.000801275 -0.006679046 -0.006556517 -0.006771877
##                             D07E10C      D07E10D      D07E10I      D07E10J
## (Intercept)            0.8097476406  0.605232341  0.620263425  0.615322890
## format_16S_L6$Group11  0.0619177898 -0.093155729 -0.074710690 -0.075631362
## format_16S_L6$Group12  0.0492804276 -0.212865325 -0.219986643 -0.206781624
## format_16S_L6$Group13  0.0767264813 -0.134180762 -0.149935842 -0.151824215
## dph                   -0.0005012391 -0.006661386 -0.006791396 -0.006033595
##                            D14E01C      D14E01D     D14E01I      D14E01J
## (Intercept)            0.800423284  0.600944853  0.62088962  0.613315262
## format_16S_L6$Group11  0.070253603 -0.111841798 -0.07346289 -0.073831486
## format_16S_L6$Group12  0.045520310 -0.197734752 -0.19418962 -0.216652405
## format_16S_L6$Group13  0.082054302 -0.123486162 -0.15475029 -0.150455682
## dph                   -0.002267959 -0.006434099 -0.00567207 -0.006441401
##                            D14E02C      D14E02D     D14E02I      D14E02J
## (Intercept)            0.794030471  0.596819891  0.62039589  0.611971039
## format_16S_L6$Group11  0.068995662 -0.121077462 -0.07408245 -0.073022828
## format_16S_L6$Group12  0.046894832 -0.182650821 -0.22081706 -0.223668533
## format_16S_L6$Group13  0.083908243 -0.117630174 -0.14883436 -0.138990802
## dph                   -0.001913106 -0.006019996 -0.00686567 -0.006875789
##                            D14E03C      D14E03D      D14E03I      D14E03J
## (Intercept)            0.820104987  0.648150896  0.592554060  0.603400216
## format_16S_L6$Group11  0.083112113 -0.102317961 -0.070792895 -0.070030242
## format_16S_L6$Group12  0.059905597 -0.077731011 -0.160964192 -0.220679680
## format_16S_L6$Group13  0.107674320 -0.046900975 -0.126776224 -0.136996311
## dph                   -0.002775945 -0.003699277 -0.003808434 -0.006645556
##                            D14E04C      D14E04D      D14E04I      D14E04J
## (Intercept)            0.804147296  0.606605475  0.637429096  0.616009109
## format_16S_L6$Group11  0.068022681 -0.100163242 -0.074957278 -0.080105888
## format_16S_L6$Group12  0.054952887 -0.197290863 -0.170712367 -0.214520385
## format_16S_L6$Group13  0.087968402 -0.122064511 -0.147313487 -0.138650014
## dph                   -0.002169438 -0.006320298 -0.005375514 -0.006445669
##                            D14E05C      D14E05D      D14E05I      D14E05J
## (Intercept)            0.818282937  0.594825212  0.687308746  0.608993511
## format_16S_L6$Group11  0.071984460 -0.120457922 -0.058577519 -0.075776761
## format_16S_L6$Group12  0.055465614 -0.157587568 -0.124298969 -0.221101322
## format_16S_L6$Group13  0.086896370 -0.104455725 -0.109741101 -0.139051580
## dph                   -0.001835556 -0.005217514 -0.003198294 -0.006648419
##                            D14E06C      D14E06D      D14E06I      D14E06J
## (Intercept)            0.807039105  0.602593806  0.617585334  0.605164958
## format_16S_L6$Group11  0.065727058 -0.112509866 -0.076009290 -0.069839498
## format_16S_L6$Group12  0.059163685 -0.194943790 -0.215915451 -0.224999787
## format_16S_L6$Group13  0.089819826 -0.120620496 -0.149853108 -0.127739375
## dph                   -0.001562265 -0.006462868 -0.006709795 -0.006904248
##                            D14E07C      D14E07D      D14E07I      D14E07J
## (Intercept)            0.832530414  0.611752546  0.621709382  0.625085997
## format_16S_L6$Group11  0.085027004 -0.095068809 -0.074872379 -0.076524409
## format_16S_L6$Group12  0.057244768 -0.212407471 -0.221134522 -0.220722177
## format_16S_L6$Group13  0.100258051 -0.134494393 -0.147296613 -0.145431045
## dph                   -0.002612981 -0.006789664 -0.006879295 -0.006889056
##                            D14E08C      D14E08D      D14E08I      D14E08J
## (Intercept)            0.798287164  0.600473584  0.619189050  0.600884640
## format_16S_L6$Group11  0.075379673 -0.119130639 -0.073656326 -0.067518007
## format_16S_L6$Group12  0.050216524 -0.184396654 -0.219821574 -0.220097555
## format_16S_L6$Group13  0.091018594 -0.116463003 -0.152281954 -0.118176929
## dph                   -0.002320409 -0.006173341 -0.006699003 -0.006866372
##                            D14E09C      D14E09D      D14E09I      D14E09J
## (Intercept)            0.851450555  0.597571801  0.736436433  0.605363822
## format_16S_L6$Group11  0.089551188 -0.103369658 -0.037178528 -0.069474410
## format_16S_L6$Group12  0.063854095 -0.198909873 -0.092900905 -0.225076682
## format_16S_L6$Group13  0.105252795 -0.117526829 -0.100291328 -0.127342777
## dph                   -0.001275253 -0.006473401 -0.002342054 -0.006913837
##                            D14E10C      D14E10D     D14E10I      D14E10J
## (Intercept)            0.832986768  0.606755174  0.77465299  0.696246621
## format_16S_L6$Group11  0.071753286 -0.119142201 -0.01689076  0.006068754
## format_16S_L6$Group12  0.054096352 -0.148537808 -0.07668036 -0.039315725
## format_16S_L6$Group13  0.094976519 -0.098334901 -0.06590010  0.005401281
## dph                   -0.002332685 -0.005293835 -0.00152433 -0.005002988
##                           D21E01C      D21E01D      D21E01I      D21E01J
## (Intercept)            0.91845951  0.703425054  0.670994867  0.612797544
## format_16S_L6$Group11  0.05101587 -0.164837021 -0.096377663 -0.075929595
## format_16S_L6$Group12  0.08112778 -0.057572841 -0.116362387 -0.223084390
## format_16S_L6$Group13  0.10217783 -0.072072395 -0.139438415 -0.137313281
## dph                   -0.00484698 -0.005896585 -0.005976493 -0.007020974
##                            D21E02C      D21E02D      D21E02I      D21E02J
## (Intercept)            0.848966384  0.603612442  0.634598291  0.633273859
## format_16S_L6$Group11  0.032563100 -0.111568486 -0.080533259 -0.080528799
## format_16S_L6$Group12  0.054113322 -0.197938654 -0.187157420 -0.186724029
## format_16S_L6$Group13  0.075769272 -0.123990877 -0.142900614 -0.130570520
## dph                   -0.004641109 -0.006512085 -0.005808852 -0.005789184
##                            D21E03C     D21E03D      D21E03I      D21E03J
## (Intercept)            0.864222973  0.65272497  0.620962917  0.601880280
## format_16S_L6$Group11  0.081198562 -0.10875144 -0.074887829 -0.070201447
## format_16S_L6$Group12  0.062444989 -0.09580675 -0.220933001 -0.223261319
## format_16S_L6$Group13  0.104404043 -0.05804268 -0.148599002 -0.124100824
## dph                   -0.003445528 -0.00472106 -0.006863293 -0.006864589
##                            D21E04C      D21E04D      D21E04I      D21E04J
## (Intercept)            0.880621970  0.597254009  0.606489569  0.600992779
## format_16S_L6$Group11  0.093917034 -0.121304597 -0.076292063 -0.058336665
## format_16S_L6$Group12  0.069533531 -0.166849261 -0.200911332 -0.188089435
## format_16S_L6$Group13  0.114673254 -0.108589441 -0.151001532 -0.099012263
## dph                   -0.002986986 -0.005705764 -0.005977211 -0.006614696
##                           D21E05C      D21E05D      D21E05I      D21E05J
## (Intercept)            0.84922044  0.627358316  0.619159887  0.604915429
## format_16S_L6$Group11  0.07197333 -0.123502082 -0.075776932 -0.070869318
## format_16S_L6$Group12  0.05064737 -0.102410121 -0.222082852 -0.223853416
## format_16S_L6$Group13  0.09750096 -0.078783274 -0.144170867 -0.127311502
## dph                   -0.00248511 -0.003789243 -0.006903592 -0.006830348
##                            D21E06C      D21E06D      D21E06I      D21E06J
## (Intercept)            0.892879663  0.597790584  0.617640535  0.743085064
## format_16S_L6$Group11  0.075020007 -0.118622345 -0.074762004  0.032550771
## format_16S_L6$Group12  0.056067625 -0.186661990 -0.217644964 -0.001144126
## format_16S_L6$Group13  0.101228881 -0.117557802 -0.150724075  0.042396722
## dph                   -0.002115389 -0.006153195 -0.006589955 -0.004443861
##                            D21E07C      D21E07D      D21E07I      D21E07J
## (Intercept)            0.808328864  0.733913130  0.748890508  0.773132222
## format_16S_L6$Group11  0.078580275 -0.079750407 -0.061352423 -0.007159610
## format_16S_L6$Group12  0.059203222 -0.062593038 -0.080439199 -0.052630970
## format_16S_L6$Group13  0.105158471 -0.043936519 -0.084387535 -0.013668452
## dph                   -0.002628345 -0.003570047 -0.002716604 -0.003063948
##                            D21E08C      D21E08D      D21E08I      D21E08J
## (Intercept)            0.881493644  0.889998243  0.644355730  0.627430987
## format_16S_L6$Group11  0.078951442 -0.131786746 -0.083620935 -0.046985438
## format_16S_L6$Group12  0.071809298  0.034547103 -0.160231668 -0.127488966
## format_16S_L6$Group13  0.108388337  0.005817256 -0.148683586 -0.060175001
## dph                   -0.003451968 -0.003875699 -0.005948597 -0.006498563
##                            D21E09C      D21E09D      D21E09I      D21E09J
## (Intercept)            0.871297303  0.829948618  0.764728044  0.602646460
## format_16S_L6$Group11  0.085535555 -0.145672583 -0.072907149 -0.061984226
## format_16S_L6$Group12  0.062844869  0.005328205 -0.060634575 -0.189408608
## format_16S_L6$Group13  0.109911786 -0.025322339 -0.109894555 -0.103731336
## dph                   -0.003464067 -0.004860332 -0.004591694 -0.006926997
##                            D21E10C      D21E10D      D21E10I     D21E10J
## (Intercept)            0.881873540  0.730836668  0.842865523  0.60587557
## format_16S_L6$Group11  0.059339837 -0.162794875 -0.069860387 -0.07129668
## format_16S_L6$Group12  0.074141394 -0.056482133 -0.007801751 -0.20191893
## format_16S_L6$Group13  0.099391551 -0.074100302 -0.073044703 -0.11167148
## dph                   -0.004037911 -0.006250866 -0.004039670 -0.00720333
##                            D28E01C      D28E01D      D28E01I     D28E01J
## (Intercept)            0.941459187  0.790097271  0.604864008  0.61786953
## format_16S_L6$Group11  0.068618904 -0.148859321 -0.091420042 -0.07660495
## format_16S_L6$Group12  0.052123952 -0.027839092 -0.201678380 -0.22215479
## format_16S_L6$Group13  0.087295545 -0.057949459 -0.142587996 -0.14242928
## dph                   -0.002629336 -0.005637696 -0.006689568 -0.00690799
##                            D28E02C      D28E02D      D28E02I      D28E02J
## (Intercept)            0.937143716  0.692528839  0.623438103  0.592942530
## format_16S_L6$Group11  0.082051919 -0.168811044 -0.103462846 -0.068572961
## format_16S_L6$Group12  0.057501276 -0.071381230 -0.136267920 -0.210289086
## format_16S_L6$Group13  0.102350234 -0.083350735 -0.135794221 -0.111229616
## dph                   -0.003282236 -0.006316184 -0.004711852 -0.006615881
##                            D28E03C      D28E03D      D28E03I      D28E03J
## (Intercept)            0.926822442  0.756129276  0.655841408  0.612100920
## format_16S_L6$Group11  0.085626223 -0.155697547 -0.125946299 -0.075299097
## format_16S_L6$Group12  0.056519707 -0.046274760 -0.145395865 -0.224024095
## format_16S_L6$Group13  0.103405794 -0.071838776 -0.134885162 -0.136589240
## dph                   -0.002890455 -0.006008588 -0.007491533 -0.006983939
##                           D28E04C      D28E04D      D28E04I      D28E04J
## (Intercept)            0.93813379  0.630845959  0.650094026  0.613709316
## format_16S_L6$Group11  0.08778754 -0.138753146 -0.124390519 -0.074217264
## format_16S_L6$Group12  0.06062013 -0.142658179 -0.152280428 -0.224367921
## format_16S_L6$Group13  0.10602532 -0.121563832 -0.135644844 -0.136472463
## dph                   -0.00365599 -0.007051063 -0.007558586 -0.007034733
##                            D28E05C      D28E05D      D28E05I     D28E05J
## (Intercept)            0.901406593  0.610375969  0.640783356  0.60989758
## format_16S_L6$Group11  0.080578450 -0.125161445 -0.116027006 -0.07343596
## format_16S_L6$Group12  0.069150794 -0.169117015 -0.168137327 -0.22463278
## format_16S_L6$Group13  0.105032332 -0.118227252 -0.140235498 -0.13293141
## dph                   -0.001955021 -0.006461321 -0.007631454 -0.00698721
##                            D28E06C      D28E06D      D28E06I      D28E06J
## (Intercept)            0.923677525  0.614996310  0.566206454  0.601260200
## format_16S_L6$Group11  0.094262739 -0.116580671 -0.083960948 -0.081968775
## format_16S_L6$Group12  0.065452616 -0.180817417 -0.165800917 -0.218242543
## format_16S_L6$Group13  0.113574797 -0.133737502 -0.139449440 -0.140012515
## dph                   -0.002975853 -0.007076709 -0.003791678 -0.006522353
##                            D28E07C      D28E07D      D28E07I      D28E07J
## (Intercept)            0.929259950  0.676623194  0.588250717  0.613667028
## format_16S_L6$Group11  0.076642243 -0.163261907 -0.084924858 -0.047790005
## format_16S_L6$Group12  0.071745924 -0.079918264 -0.179685028 -0.137607248
## format_16S_L6$Group13  0.101908607 -0.084764992 -0.138725980 -0.065447766
## dph                   -0.003503851 -0.006283104 -0.005967179 -0.006158846
##                            D28E08C      D28E08D     D28E08I      D28E08J
## (Intercept)            0.930111292  0.781903804  0.61370429  0.596700091
## format_16S_L6$Group11  0.083709424 -0.105376043 -0.09043085 -0.083188872
## format_16S_L6$Group12  0.055694062  0.020716175 -0.18112825 -0.163997805
## format_16S_L6$Group13  0.101935607 -0.010966621 -0.15067750 -0.119768278
## dph                   -0.003269311 -0.002834822 -0.00630260 -0.006120759
##                            D28E09C      D28E09D      D28E09I     D28E09J
## (Intercept)            0.941263733  0.659593539  0.644211534  0.60872338
## format_16S_L6$Group11  0.071567368 -0.144121170 -0.092762124 -0.07351092
## format_16S_L6$Group12  0.048606226 -0.128343191 -0.063965476 -0.22444693
## format_16S_L6$Group13  0.089409949 -0.120373008 -0.116770560 -0.13289232
## dph                   -0.002689566 -0.007333259 -0.002464063 -0.00697915
##                            D28E10C      D28E10D      D28E10I      D28E10J
## (Intercept)            0.903224131  0.665961066  0.712645246  0.590511846
## format_16S_L6$Group11  0.098201670 -0.160451910 -0.115840833 -0.081876953
## format_16S_L6$Group12  0.073260476 -0.074237226 -0.023020987 -0.208513979
## format_16S_L6$Group13  0.118401252 -0.086802407 -0.079061756 -0.124970567
## dph                   -0.002398319 -0.005666837 -0.002989982 -0.006502164
##                            D35E01C      D35E01D      D35E01I      D35E01J
## (Intercept)            0.918660859  0.912667167  0.619537257  0.595033244
## format_16S_L6$Group11  0.079505258 -0.126138885 -0.092366469 -0.076334060
## format_16S_L6$Group12  0.079782340  0.041051707 -0.200698701 -0.217473805
## format_16S_L6$Group13  0.114135326  0.010696810 -0.146511639 -0.128259735
## dph                   -0.004259844 -0.003749154 -0.007327021 -0.006690728
##                            D35E02C     D35E02D      D35E02I      D35E02J
## (Intercept)            0.921628501  0.76982498  0.833587885  0.602684711
## format_16S_L6$Group11  0.100056152 -0.15915282 -0.050892442 -0.070150916
## format_16S_L6$Group12  0.071434473 -0.03245929 -0.015671362 -0.223401516
## format_16S_L6$Group13  0.120834489 -0.05958432 -0.073571603 -0.123767807
## dph                   -0.003866525 -0.00581639 -0.003252661 -0.006920366
##                            D35E03C      D35E03D      D35E03I      D35E03J
## (Intercept)            0.910170576  0.634941698  0.612628535  0.613744849
## format_16S_L6$Group11  0.094543505 -0.133625588 -0.092249238 -0.076855544
## format_16S_L6$Group12  0.066398286 -0.153757693 -0.180361769 -0.222213943
## format_16S_L6$Group13  0.116576341 -0.127941457 -0.148714874 -0.138032957
## dph                   -0.003734897 -0.007392399 -0.006723438 -0.007073305
##                            D35E04C      D35E04D      D35E04I      D35E04J
## (Intercept)            0.898742752  0.828608171  0.683208202  0.607459388
## format_16S_L6$Group11  0.081802429 -0.151325627 -0.074052781 -0.055281711
## format_16S_L6$Group12  0.062520863  0.009221570 -0.061797941 -0.167457403
## format_16S_L6$Group13  0.100117758 -0.021575654 -0.115429796 -0.085140674
## dph                   -0.003292123 -0.004817901 -0.002712873 -0.006724633
##                            D35E05C      D35E05D      D35E05I      D35E05J
## (Intercept)            0.923350486  0.716441328  0.637361185  0.612121154
## format_16S_L6$Group11  0.086928689 -0.162585675 -0.062580723 -0.078721171
## format_16S_L6$Group12  0.072955341 -0.035674531 -0.121877639 -0.219602722
## format_16S_L6$Group13  0.111310343 -0.059662567 -0.076703753 -0.143655288
## dph                   -0.003924332 -0.005292864 -0.006539158 -0.006796104
##                            D35E06C     D35E06D      D35E06I      D35E06J
## (Intercept)            0.865236913  0.66717534  0.625205993  0.616498083
## format_16S_L6$Group11  0.089612659 -0.15839211 -0.111004797 -0.078650593
## format_16S_L6$Group12  0.066382580 -0.09518247 -0.151620314 -0.219916802
## format_16S_L6$Group13  0.102335851 -0.09505541 -0.132526035 -0.140852452
## dph                   -0.003040948 -0.00669491 -0.006936694 -0.007120568
##                            D35E07C      D35E07D      D35E07I     D35E07J
## (Intercept)            0.877230814  0.877337435  0.698295395  0.59665661
## format_16S_L6$Group11  0.094965606 -0.133680473 -0.082059779 -0.05945286
## format_16S_L6$Group12  0.065771055  0.025848872 -0.063543759 -0.19207540
## format_16S_L6$Group13  0.108664991 -0.001960322 -0.123181788 -0.10103427
## dph                   -0.003120886 -0.004265434 -0.003989189 -0.00660287
##                             D35E08C      D35E08D      D35E08I      D35E08J
## (Intercept)            0.7911367421  0.664276525  0.608994142  0.614650794
## format_16S_L6$Group11  0.0587810481 -0.140043910 -0.058331994 -0.081428181
## format_16S_L6$Group12  0.0437130703 -0.077541576 -0.144962032 -0.216768757
## format_16S_L6$Group13  0.0901064531 -0.070179153 -0.078299995 -0.134681286
## dph                   -0.0001852313 -0.006028915 -0.005806683 -0.007281069
##                            D35E09C      D35E09D      D35E09I      D35E09J
## (Intercept)            0.922114695  0.694482703  0.642638466  0.602541302
## format_16S_L6$Group11  0.095811277 -0.159538398 -0.113845807 -0.068162359
## format_16S_L6$Group12  0.066287478 -0.088505117 -0.157847227 -0.207793814
## format_16S_L6$Group13  0.116859776 -0.094032255 -0.142351671 -0.110672662
## dph                   -0.003773473 -0.006881168 -0.007409943 -0.007067688
##                            D35E10C      D35E10D      D35E10I      D35E10J
## (Intercept)            0.890148940  0.628535122  0.690858749  0.588978223
## format_16S_L6$Group11  0.099463902 -0.122702323 -0.076608833 -0.082171644
## format_16S_L6$Group12  0.072950016 -0.168389530 -0.028658207 -0.197358998
## format_16S_L6$Group13  0.115906457 -0.133249839 -0.094722887 -0.128030643
## dph                   -0.003070752 -0.007463622 -0.000628044 -0.006380858
##                           D42E01C      D42E01D      D42E01I      D42E01J
## (Intercept)            0.90977554  0.611620653  0.628173933  0.624398852
## format_16S_L6$Group11  0.08445856 -0.120666015 -0.087270431 -0.077120650
## format_16S_L6$Group12  0.06125448 -0.179691387 -0.209182751 -0.220791098
## format_16S_L6$Group13  0.10876421 -0.119727003 -0.145577775 -0.144745150
## dph                   -0.00340253 -0.006647833 -0.007486824 -0.006951586
##                            D42E02C      D42E02D      D42E02I      D42E02J
## (Intercept)            0.883624765  0.633780210  0.627772608  0.598799252
## format_16S_L6$Group11  0.091617550 -0.127814806 -0.077009989 -0.061571405
## format_16S_L6$Group12  0.069160937 -0.162304708 -0.220081413 -0.200916429
## format_16S_L6$Group13  0.114842675 -0.130186544 -0.145895528 -0.103377484
## dph                   -0.003228461 -0.007479492 -0.006906898 -0.006800167
##                            D42E03C      D42E03D      D42E03I      D42E03J
## (Intercept)            0.888617557  0.837583456  0.609357085  0.622686809
## format_16S_L6$Group11  0.099819807 -0.146487361 -0.074089655 -0.076536068
## format_16S_L6$Group12  0.075633294  0.008772433 -0.223472029 -0.221183759
## format_16S_L6$Group13  0.125841044 -0.024116536 -0.140059294 -0.143921894
## dph                   -0.003229411 -0.004786418 -0.006852018 -0.007033751
##                            D42E04C      D42E04D      D42E04I      D42E04J
## (Intercept)            0.866169730  0.659398185  0.619274647  0.601668774
## format_16S_L6$Group11  0.093537026 -0.151683138 -0.077489347 -0.067937378
## format_16S_L6$Group12  0.072742052 -0.117873547 -0.218971755 -0.220176283
## format_16S_L6$Group13  0.104136412 -0.110318701 -0.147937153 -0.122845511
## dph                   -0.002733063 -0.007124719 -0.006934773 -0.006906753
##                           D42E05C     D42E05D      D42E05I      D42E05J
## (Intercept)            0.90367455  0.61534519  0.622111102  0.616297897
## format_16S_L6$Group11  0.08009984 -0.09794685 -0.078341627 -0.078552070
## format_16S_L6$Group12  0.06608042 -0.20472438 -0.218399796 -0.221925857
## format_16S_L6$Group13  0.10494825 -0.13189781 -0.145793478 -0.138744963
## dph                   -0.00364865 -0.00709276 -0.007182723 -0.006952854
##                            D42E06C     D42E06D      D42E06I      D42E06J
## (Intercept)            0.895642182  0.61473062  0.625644716  0.624312000
## format_16S_L6$Group11  0.093127032 -0.09133352 -0.076102867 -0.076394160
## format_16S_L6$Group12  0.064546697 -0.21408924 -0.220598637 -0.221241883
## format_16S_L6$Group13  0.115331152 -0.13585628 -0.147113398 -0.144655786
## dph                   -0.003532945 -0.00686657 -0.006924389 -0.006918853
##                           D42E07C      D42E07D     D42E07I      D42E07J
## (Intercept)            0.83415809  0.621887803  0.62787385  0.624369334
## format_16S_L6$Group11  0.08559102 -0.086607600 -0.07720301 -0.075847737
## format_16S_L6$Group12  0.06727074 -0.213881302 -0.21933870 -0.220779692
## format_16S_L6$Group13  0.10680228 -0.140381313 -0.14614367 -0.147401544
## dph                   -0.00333280 -0.007277581 -0.00707651 -0.006912434
##                            D42E08C      D42E08D      D42E08I      D42E08J
## (Intercept)            0.906417287  0.629773500  0.624261624  0.603408696
## format_16S_L6$Group11  0.097633952 -0.122799045 -0.075603893 -0.070277282
## format_16S_L6$Group12  0.068650343 -0.127261410 -0.220543374 -0.223913979
## format_16S_L6$Group13  0.120226750 -0.099159057 -0.148040555 -0.124610833
## dph                   -0.003645503 -0.005844394 -0.006923992 -0.006922961
##                            D42E09C      D42E09D      D42E09I      D42E09J
## (Intercept)            0.873401332  0.886071352  0.595908025  0.601360574
## format_16S_L6$Group11  0.087798227 -0.125159000 -0.080219245 -0.094457743
## format_16S_L6$Group12  0.067315292  0.027191630 -0.209825906 -0.183720498
## format_16S_L6$Group13  0.102790912 -0.003827972 -0.145605159 -0.135806262
## dph                   -0.002548382 -0.004124356 -0.006071409 -0.006646576
##                            D42E10C     D42E10D      D42E10I      D42E10J
## (Intercept)            0.875331687  0.71558898  0.616060135  0.617048435
## format_16S_L6$Group11  0.087600464 -0.15320981 -0.075556933 -0.075030139
## format_16S_L6$Group12  0.069562047 -0.08151820 -0.216518352 -0.223712030
## format_16S_L6$Group13  0.111815217 -0.09236876 -0.151847450 -0.139718827
## dph                   -0.002393304 -0.00678512 -0.006672435 -0.006962786
## 
## $f.perms
##              [,1]       [,2]
##    [1,] 0.6773340 0.98312421
##    [2,] 2.4346132 0.36069032
##    [3,] 1.1359539 0.08850190
##    [4,] 0.9139585 1.02844715
##    [5,] 0.6222011 0.60349726
##    [6,] 0.4320309 0.32896902
##    [7,] 0.6159131 0.34732387
##    [8,] 1.6625012 1.53414064
##    [9,] 0.9122893 2.13350779
##   [10,] 1.0863469 1.31547631
##   [11,] 0.9290719 0.56238400
##   [12,] 0.9951633 0.19767775
##   [13,] 0.7784327 0.88805602
##   [14,] 0.8103380 0.34770831
##   [15,] 0.6644589 1.20476326
##   [16,] 0.9333702 0.56875863
##   [17,] 0.6251541 0.50733823
##   [18,] 1.2261462 0.85338297
##   [19,] 0.7390423 0.76568625
##   [20,] 0.4736717 1.23740064
##   [21,] 0.5331065 1.21258548
##   [22,] 0.4988934 3.16452505
##   [23,] 0.8870171 0.37073547
##   [24,] 1.0552595 0.58092858
##   [25,] 0.6046108 1.06102073
##   [26,] 0.7468511 0.50322573
##   [27,] 1.1119234 1.48179585
##   [28,] 0.7084676 1.98892903
##   [29,] 0.7417289 0.86594243
##   [30,] 0.5917851 2.87888755
##   [31,] 0.5096578 0.88769691
##   [32,] 1.4326833 0.84990629
##   [33,] 0.7633935 1.44959304
##   [34,] 1.0516518 1.09944399
##   [35,] 0.9546582 1.49272983
##   [36,] 1.2747090 0.43670658
##   [37,] 1.3354077 0.38575087
##   [38,] 1.2339750 1.33998190
##   [39,] 0.7392007 1.99537907
##   [40,] 1.8077338 1.22630197
##   [41,] 0.9307894 0.70909062
##   [42,] 0.6285212 1.21585883
##   [43,] 0.3653636 0.70971287
##   [44,] 1.9170027 1.35451135
##   [45,] 0.7874494 1.23387644
##   [46,] 0.3983841 0.44056452
##   [47,] 1.3215796 2.49456978
##   [48,] 0.5221135 0.53954053
##   [49,] 1.5105978 1.22425159
##   [50,] 0.7797397 1.49027619
##   [51,] 0.6422583 0.37784945
##   [52,] 0.8915385 0.47439829
##   [53,] 0.8689626 1.21378205
##   [54,] 1.8449724 0.31394864
##   [55,] 1.9673651 0.37191603
##   [56,] 3.1388578 0.47355149
##   [57,] 1.0234997 0.73319406
##   [58,] 1.2513439 0.52868236
##   [59,] 0.5494361 0.83465650
##   [60,] 0.7280154 0.75164553
##   [61,] 1.9868822 2.23246449
##   [62,] 0.8556785 0.91787083
##   [63,] 0.5284411 0.51370201
##   [64,] 0.4675997 0.38566909
##   [65,] 0.6733270 1.13168306
##   [66,] 0.8796345 1.55445529
##   [67,] 0.8570021 0.20542728
##   [68,] 0.9332993 0.92032048
##   [69,] 1.2341441 1.23940731
##   [70,] 1.5962441 0.79153178
##   [71,] 1.1939702 0.54570831
##   [72,] 0.8381967 2.86660879
##   [73,] 0.8459142 2.43801775
##   [74,] 0.8409164 1.53834878
##   [75,] 1.0040765 0.76053326
##   [76,] 0.9641782 0.95354964
##   [77,] 1.2623840 1.03073380
##   [78,] 0.9100656 2.33584478
##   [79,] 1.3345149 1.20587898
##   [80,] 0.5248089 0.62542963
##   [81,] 0.7589038 0.08609961
##   [82,] 0.9699188 0.48344604
##   [83,] 0.6493623 0.59719335
##   [84,] 0.4273760 0.98726180
##   [85,] 0.8022370 2.55082212
##   [86,] 1.0481101 1.56658140
##   [87,] 1.7843836 0.32118272
##   [88,] 1.3316740 0.82326175
##   [89,] 1.2378470 0.83088599
##   [90,] 2.0845988 0.83964586
##   [91,] 0.6652580 0.78303826
##   [92,] 1.5488911 1.51114672
##   [93,] 0.8634077 0.39501165
##   [94,] 0.6462648 1.40776252
##   [95,] 1.0415781 1.43309863
##   [96,] 1.1047482 0.86511450
##   [97,] 0.9563674 1.55735538
##   [98,] 1.2046799 0.64935999
##   [99,] 0.6259905 0.99406022
##  [100,] 0.6799214 0.67990109
##  [101,] 0.9297499 0.74268611
##  [102,] 0.8050790 0.34708607
##  [103,] 1.0964121 0.75029432
##  [104,] 0.8272084 1.22481052
##  [105,] 0.8512609 2.03688811
##  [106,] 0.6793707 1.88712901
##  [107,] 1.6095509 1.75044532
##  [108,] 0.6691876 0.51092094
##  [109,] 0.4298913 1.16190966
##  [110,] 1.1154949 1.15654100
##  [111,] 1.3204022 0.95429448
##  [112,] 1.1348087 0.43241183
##  [113,] 0.9297035 0.53821174
##  [114,] 1.0083750 0.65927283
##  [115,] 1.0030674 1.59616340
##  [116,] 0.8419621 1.22315596
##  [117,] 0.6574543 1.63065127
##  [118,] 0.6764877 0.93420902
##  [119,] 1.0496677 0.97416262
##  [120,] 0.3390001 0.67952739
##  [121,] 0.7342363 0.29270948
##  [122,] 0.5886737 1.28510354
##  [123,] 1.3726799 0.32845230
##  [124,] 1.1981537 0.42171667
##  [125,] 1.4605164 0.47059768
##  [126,] 0.9932967 1.02350171
##  [127,] 0.4405533 0.92225052
##  [128,] 0.8460931 1.08176534
##  [129,] 1.1884898 1.37261679
##  [130,] 1.4790997 1.27394928
##  [131,] 0.8324539 1.42280767
##  [132,] 0.6562233 0.40604555
##  [133,] 1.1036994 0.52817160
##  [134,] 0.9408722 0.58296928
##  [135,] 1.1666111 0.43954899
##  [136,] 1.1116689 0.64178955
##  [137,] 1.1925761 0.73724059
##  [138,] 0.7259956 1.36055584
##  [139,] 0.8345696 0.90655386
##  [140,] 0.9960858 1.64072523
##  [141,] 0.4963651 0.26927915
##  [142,] 0.6424163 2.12965267
##  [143,] 0.8947276 2.56599258
##  [144,] 0.7404526 0.37416584
##  [145,] 0.6014052 0.72551839
##  [146,] 1.1105113 0.77456307
##  [147,] 0.6723857 0.89201001
##  [148,] 0.8141324 0.46915341
##  [149,] 0.4144765 0.33470500
##  [150,] 0.7582506 1.03739078
##  [151,] 0.7612176 0.52415917
##  [152,] 1.2129611 0.31762389
##  [153,] 0.5009314 0.59695182
##  [154,] 0.5141227 0.49091980
##  [155,] 1.2492072 0.45667360
##  [156,] 0.7494259 0.82437708
##  [157,] 1.6316541 0.47766742
##  [158,] 0.6410136 1.05326064
##  [159,] 1.1833721 0.38223028
##  [160,] 1.2249044 1.95410661
##  [161,] 0.2919664 0.43989902
##  [162,] 0.5958205 1.48624672
##  [163,] 0.6514741 0.52515476
##  [164,] 1.1302224 1.06499769
##  [165,] 0.6916036 1.85789778
##  [166,] 0.8852500 1.53061993
##  [167,] 0.8000435 0.39871413
##  [168,] 0.5017761 1.94947545
##  [169,] 1.3764002 0.38347920
##  [170,] 1.0006110 0.76801255
##  [171,] 0.9137099 0.39966350
##  [172,] 0.8800599 1.04541771
##  [173,] 0.7528758 0.72616905
##  [174,] 0.9058105 0.52465132
##  [175,] 1.0410110 2.40988940
##  [176,] 1.2081695 1.01678636
##  [177,] 1.2343823 0.35266649
##  [178,] 0.6218174 0.99519771
##  [179,] 1.0076931 0.72056597
##  [180,] 0.8532019 1.94166071
##  [181,] 0.5790299 0.29828424
##  [182,] 0.4458330 0.25086818
##  [183,] 1.4107927 0.72833851
##  [184,] 0.6295945 0.34637618
##  [185,] 0.9863241 2.20761445
##  [186,] 1.2337592 0.49929003
##  [187,] 0.8418280 0.45738205
##  [188,] 0.8663924 0.78245261
##  [189,] 0.5899578 0.60274382
##  [190,] 0.6306428 0.60387334
##  [191,] 0.6376634 1.16542918
##  [192,] 0.9710557 1.00011362
##  [193,] 1.0976441 1.09806801
##  [194,] 1.0891214 0.44663980
##  [195,] 0.9895711 0.30550291
##  [196,] 0.9140497 0.58341068
##  [197,] 0.9305263 0.44871688
##  [198,] 1.0137361 2.05049894
##  [199,] 1.5847561 0.91492151
##  [200,] 0.7210180 0.85203688
##  [201,] 2.0031977 1.13022770
##  [202,] 1.4616506 0.82950991
##  [203,] 0.8414661 0.60400472
##  [204,] 0.7017062 0.44367881
##  [205,] 0.6861842 0.91572941
##  [206,] 0.8315567 2.44004908
##  [207,] 1.2133004 0.65579502
##  [208,] 1.2747508 1.43551058
##  [209,] 1.0692087 0.75332551
##  [210,] 1.3638453 3.55737666
##  [211,] 1.6957179 2.37334845
##  [212,] 1.2885887 0.67105236
##  [213,] 0.5991566 3.85948058
##  [214,] 1.4602957 1.96524561
##  [215,] 1.3922932 1.99907264
##  [216,] 1.5693200 0.77556285
##  [217,] 0.8997305 0.29436139
##  [218,] 1.5344361 1.18242687
##  [219,] 0.7091385 0.38457586
##  [220,] 0.7733667 0.51119741
##  [221,] 0.7616445 0.49947719
##  [222,] 1.4189273 0.76155608
##  [223,] 1.1177718 0.87968748
##  [224,] 0.8480980 1.22141683
##  [225,] 1.2227874 0.76309184
##  [226,] 1.5256927 0.75822380
##  [227,] 1.5835236 1.55896771
##  [228,] 1.0403206 0.78163662
##  [229,] 1.0929858 0.27250979
##  [230,] 1.0577792 4.02602951
##  [231,] 0.8064850 1.00330205
##  [232,] 0.3956347 2.26896510
##  [233,] 0.8416428 0.22377281
##  [234,] 1.1163822 1.20666131
##  [235,] 1.2513233 0.26146077
##  [236,] 1.3654802 0.74572695
##  [237,] 0.4697079 1.87225561
##  [238,] 0.3676314 1.30289725
##  [239,] 0.5001945 1.05470996
##  [240,] 1.6992291 2.16981692
##  [241,] 0.3537202 3.90805227
##  [242,] 0.8158085 0.35779976
##  [243,] 0.7177362 1.29318343
##  [244,] 0.9356383 1.04740813
##  [245,] 0.3570694 0.79388665
##  [246,] 0.9602671 1.06104500
##  [247,] 0.5755260 0.55486395
##  [248,] 0.7883570 0.36040783
##  [249,] 1.5541952 0.32359094
##  [250,] 0.5944626 0.47465230
##  [251,] 0.9693833 0.74642776
##  [252,] 0.9746285 1.46951148
##  [253,] 0.5634571 1.02577734
##  [254,] 1.0244091 0.83048408
##  [255,] 2.0579440 0.31212749
##  [256,] 1.4400055 0.34715752
##  [257,] 0.9336669 0.72820989
##  [258,] 0.5345002 1.34044440
##  [259,] 0.5107554 0.66066393
##  [260,] 1.0115337 0.48250238
##  [261,] 0.6742558 1.65408362
##  [262,] 0.8783602 1.89516722
##  [263,] 0.8998746 0.60147386
##  [264,] 0.6598238 1.44543896
##  [265,] 1.1977701 0.44194279
##  [266,] 1.6877442 0.20318708
##  [267,] 0.7767811 0.88129392
##  [268,] 0.5926351 1.29973215
##  [269,] 0.5367517 1.22847480
##  [270,] 1.8047676 1.02516026
##  [271,] 1.6584697 0.35108718
##  [272,] 1.5800234 0.51476313
##  [273,] 1.1969544 1.54430488
##  [274,] 1.0066535 1.46754274
##  [275,] 0.6436028 0.76339253
##  [276,] 0.7648374 0.50927496
##  [277,] 0.8935542 1.98910255
##  [278,] 0.7831887 0.41240149
##  [279,] 0.8029590 0.65217324
##  [280,] 0.8100733 1.74476040
##  [281,] 1.1191284 1.37933194
##  [282,] 0.6640231 0.80024501
##  [283,] 1.3210248 1.58512009
##  [284,] 0.7985647 0.32472356
##  [285,] 1.2871881 1.17825522
##  [286,] 1.2975231 1.96771679
##  [287,] 0.9090311 4.40369905
##  [288,] 0.9793731 1.53861776
##  [289,] 0.8750431 0.30248994
##  [290,] 0.9558739 0.98575962
##  [291,] 0.9780960 0.89574589
##  [292,] 1.0169402 1.01895490
##  [293,] 1.0054956 1.27836601
##  [294,] 1.6397959 1.06674601
##  [295,] 1.0990976 1.08588116
##  [296,] 0.4643074 0.52641523
##  [297,] 0.8496622 0.73421751
##  [298,] 1.1383781 0.40451712
##  [299,] 2.1398659 0.69256151
##  [300,] 0.6145661 0.49967365
##  [301,] 0.6942086 2.49947180
##  [302,] 0.8876612 0.82836235
##  [303,] 0.9406433 1.15326440
##  [304,] 0.6788393 0.87776996
##  [305,] 0.9131155 0.52532640
##  [306,] 1.3686891 1.27663615
##  [307,] 0.8571608 1.92777226
##  [308,] 0.8560677 0.29569937
##  [309,] 1.0700601 0.60215634
##  [310,] 0.3355383 0.98427331
##  [311,] 0.4839797 0.87849904
##  [312,] 0.4117750 0.34466266
##  [313,] 0.8666538 1.51478411
##  [314,] 0.4448246 0.67995468
##  [315,] 1.5330167 1.71045471
##  [316,] 1.6484459 0.28555506
##  [317,] 0.7718651 0.99316915
##  [318,] 1.2544397 0.63295085
##  [319,] 0.6965335 1.25103752
##  [320,] 2.0422798 1.58662080
##  [321,] 0.6401344 0.26106373
##  [322,] 0.9959225 0.48106760
##  [323,] 0.7529071 0.40422247
##  [324,] 0.8882721 0.87694763
##  [325,] 1.7072941 0.81774605
##  [326,] 0.8082761 0.50949015
##  [327,] 1.0429506 0.89614470
##  [328,] 0.7933456 0.63740505
##  [329,] 0.7509306 0.50581106
##  [330,] 0.6791041 0.37826520
##  [331,] 1.4405869 2.51842307
##  [332,] 1.3251547 0.61005686
##  [333,] 1.2686026 0.63742261
##  [334,] 1.0575710 0.37331303
##  [335,] 0.9319020 1.08848189
##  [336,] 1.4387885 2.22638018
##  [337,] 0.8247363 1.65845013
##  [338,] 0.9268728 0.21199821
##  [339,] 0.8233520 1.23626036
##  [340,] 1.0250348 1.31467518
##  [341,] 0.6645259 0.78485674
##  [342,] 1.0188446 1.06720247
##  [343,] 0.6578055 0.89461570
##  [344,] 1.2149198 1.11590973
##  [345,] 1.0348870 1.49430151
##  [346,] 0.5920543 0.73969994
##  [347,] 2.4009753 0.68351596
##  [348,] 1.1240370 0.97321845
##  [349,] 0.5786999 0.60621077
##  [350,] 1.3647506 0.24035877
##  [351,] 1.3211194 0.38083136
##  [352,] 0.7074837 1.69898994
##  [353,] 0.7363671 0.62038204
##  [354,] 0.7486865 0.60171391
##  [355,] 0.8459462 1.64212596
##  [356,] 1.1430780 4.04649865
##  [357,] 0.9714087 1.57315885
##  [358,] 0.8686630 0.53908616
##  [359,] 0.8916788 1.28923498
##  [360,] 1.2142489 1.53686659
##  [361,] 0.6171759 0.32827817
##  [362,] 0.8873342 1.42949356
##  [363,] 0.9620406 1.56231313
##  [364,] 1.2795819 0.30646222
##  [365,] 2.0037061 1.01894749
##  [366,] 1.4623616 1.77835424
##  [367,] 0.7738335 1.00592612
##  [368,] 1.3662935 0.20783484
##  [369,] 0.9192478 0.32389617
##  [370,] 0.5473974 0.50296444
##  [371,] 0.5396000 0.93912340
##  [372,] 2.2872149 1.44985473
##  [373,] 1.1372855 1.05770500
##  [374,] 1.5066386 0.58582145
##  [375,] 0.7834081 2.50258211
##  [376,] 0.6257182 0.79930706
##  [377,] 0.7055421 0.48268550
##  [378,] 0.7684114 2.35826128
##  [379,] 0.9903498 0.37366394
##  [380,] 0.9716998 0.35333088
##  [381,] 1.3437552 0.96669995
##  [382,] 1.3597502 0.59564749
##  [383,] 0.6226803 1.02696629
##  [384,] 0.7744748 0.71429180
##  [385,] 0.7436207 0.93260633
##  [386,] 1.3379740 1.51088844
##  [387,] 0.7676511 0.90051978
##  [388,] 0.9604661 0.54117708
##  [389,] 0.8817128 0.51377887
##  [390,] 0.8107077 0.60856488
##  [391,] 0.7308164 2.22930108
##  [392,] 0.7092093 0.71176333
##  [393,] 0.5558553 1.73689918
##  [394,] 0.7999135 0.72039467
##  [395,] 0.3593200 0.84920787
##  [396,] 0.7397363 1.36442681
##  [397,] 0.9492809 1.94840817
##  [398,] 0.5568720 0.42975894
##  [399,] 0.7917128 3.00656010
##  [400,] 1.0464018 0.43571614
##  [401,] 1.1838459 0.57096277
##  [402,] 1.1848980 0.35909492
##  [403,] 1.2917694 1.58766780
##  [404,] 0.9067292 3.08043510
##  [405,] 1.5321219 0.81653375
##  [406,] 1.0729358 0.71210540
##  [407,] 0.9472001 1.01280177
##  [408,] 0.9152259 1.18893058
##  [409,] 0.8031922 0.34465827
##  [410,] 0.7902437 1.34459573
##  [411,] 0.7802978 0.95462601
##  [412,] 0.6858742 1.56138195
##  [413,] 0.3396703 0.64469190
##  [414,] 0.9298274 0.76078957
##  [415,] 0.8082260 0.46491851
##  [416,] 0.5948483 0.51782093
##  [417,] 1.4364780 0.36133835
##  [418,] 0.6287329 1.47589052
##  [419,] 1.1170406 0.56207106
##  [420,] 0.8813064 0.45774552
##  [421,] 0.6844120 0.30527646
##  [422,] 1.8426457 0.32278228
##  [423,] 1.1438079 1.80944609
##  [424,] 1.0457010 0.66709587
##  [425,] 1.3082236 0.67063226
##  [426,] 0.6275156 0.42585907
##  [427,] 1.5768842 1.52670217
##  [428,] 0.3946649 1.08527770
##  [429,] 0.8751421 0.58375662
##  [430,] 0.6894777 0.68417538
##  [431,] 0.7480555 1.40682641
##  [432,] 0.9973192 2.18347117
##  [433,] 1.0278416 0.24181843
##  [434,] 1.1571852 0.90265075
##  [435,] 0.8951910 0.71105074
##  [436,] 0.8833674 0.95533308
##  [437,] 0.8479475 0.56609041
##  [438,] 0.9846562 1.28805151
##  [439,] 1.6451705 0.04531606
##  [440,] 0.7205295 1.02047953
##  [441,] 0.5294189 0.20329568
##  [442,] 0.7767897 0.75118870
##  [443,] 1.9759956 0.23519705
##  [444,] 0.7781464 0.31769454
##  [445,] 0.4019027 0.40362968
##  [446,] 0.4402579 0.39498860
##  [447,] 0.9107395 0.44140735
##  [448,] 1.3637855 0.39528612
##  [449,] 1.6254937 0.62013116
##  [450,] 0.7130487 1.06394771
##  [451,] 0.4921699 0.79835422
##  [452,] 1.3005296 0.59003331
##  [453,] 1.0309830 1.81682667
##  [454,] 1.1025430 0.22771721
##  [455,] 2.0153710 0.40672643
##  [456,] 1.0202717 2.21505584
##  [457,] 2.6113509 0.65864232
##  [458,] 0.5037127 0.61546409
##  [459,] 1.5145018 1.29557876
##  [460,] 1.6031535 0.85888833
##  [461,] 0.7792454 0.44874358
##  [462,] 2.1733180 0.67823704
##  [463,] 1.7034083 1.39716140
##  [464,] 0.7455380 1.45068375
##  [465,] 1.1194583 0.67313033
##  [466,] 1.3729566 0.18534469
##  [467,] 2.0401498 0.48940588
##  [468,] 0.4745826 0.35273781
##  [469,] 0.5145154 0.77157620
##  [470,] 1.6938100 0.44684567
##  [471,] 0.9913673 0.43403414
##  [472,] 0.8583370 0.35342995
##  [473,] 0.9651367 1.86324403
##  [474,] 0.4392449 0.68584459
##  [475,] 1.5874405 0.57371674
##  [476,] 0.7550062 0.61780030
##  [477,] 0.6783323 0.65166299
##  [478,] 0.9789014 1.46914922
##  [479,] 0.4067579 3.83186828
##  [480,] 0.7728724 2.68873015
##  [481,] 1.1454694 0.43603631
##  [482,] 1.1147006 0.80471500
##  [483,] 1.1260192 0.69268210
##  [484,] 0.3227537 1.06232000
##  [485,] 0.7942967 0.57167758
##  [486,] 0.6094940 1.45526037
##  [487,] 0.7723132 0.68985570
##  [488,] 1.0647145 0.52447412
##  [489,] 1.0535267 0.63820138
##  [490,] 1.3968832 1.08786512
##  [491,] 2.0197945 2.13907891
##  [492,] 0.6875867 1.53968305
##  [493,] 0.8256059 2.80647188
##  [494,] 0.6056241 0.31524510
##  [495,] 2.5735676 2.57481365
##  [496,] 0.8302146 0.73337576
##  [497,] 1.1777557 1.37106749
##  [498,] 1.4579323 1.18904493
##  [499,] 1.1613193 0.66321562
##  [500,] 0.6455606 0.68761344
##  [501,] 1.0957368 0.47875340
##  [502,] 1.0021151 0.52229594
##  [503,] 0.8533190 0.63408818
##  [504,] 1.2876291 0.12312889
##  [505,] 0.9106880 0.60466741
##  [506,] 1.2754653 1.19648128
##  [507,] 0.4903771 0.89983051
##  [508,] 0.4598692 1.08783088
##  [509,] 1.0308135 3.52507184
##  [510,] 0.5268149 0.56117786
##  [511,] 1.2610315 0.34577023
##  [512,] 1.9037958 1.39988988
##  [513,] 0.9304499 2.48486774
##  [514,] 1.0811607 1.24158435
##  [515,] 1.2807609 1.06341327
##  [516,] 1.2330736 0.59325180
##  [517,] 0.6226364 1.58130471
##  [518,] 1.3666800 1.75187409
##  [519,] 1.0988118 1.38726544
##  [520,] 0.4589977 2.88214683
##  [521,] 1.0620810 0.47520880
##  [522,] 0.7296888 2.35977081
##  [523,] 1.3397454 1.92931990
##  [524,] 1.0057580 1.12168336
##  [525,] 1.0376880 1.93268424
##  [526,] 0.9574579 0.96169631
##  [527,] 0.5879233 0.50079592
##  [528,] 0.7337902 1.04339976
##  [529,] 1.1627532 1.33344141
##  [530,] 0.6794950 1.13705548
##  [531,] 0.8071674 0.15854091
##  [532,] 0.7963095 1.43416147
##  [533,] 0.8254442 0.31982496
##  [534,] 0.5875430 0.96617987
##  [535,] 0.6552127 0.71119544
##  [536,] 0.5507233 1.44486467
##  [537,] 1.7461330 0.61018867
##  [538,] 0.5589856 0.62976982
##  [539,] 1.2443356 0.19500866
##  [540,] 0.7976728 0.67507993
##  [541,] 1.1899722 0.35345781
##  [542,] 0.6203676 1.50304860
##  [543,] 1.1230515 1.59302873
##  [544,] 0.7841222 0.95079737
##  [545,] 1.3512701 1.46129015
##  [546,] 1.2366000 0.76525819
##  [547,] 1.3916510 0.51594331
##  [548,] 0.7689582 1.03088323
##  [549,] 0.8056471 1.18520120
##  [550,] 0.6749061 0.71623635
##  [551,] 0.9969918 0.75081898
##  [552,] 2.5381774 0.41436936
##  [553,] 0.6959306 0.46684427
##  [554,] 0.9072028 0.70207866
##  [555,] 1.2673348 0.93044514
##  [556,] 1.3656441 2.79940972
##  [557,] 0.8396492 1.15989453
##  [558,] 0.9015681 0.26290624
##  [559,] 0.7952952 0.20273719
##  [560,] 0.6473068 0.56376367
##  [561,] 1.4016982 2.24808924
##  [562,] 0.2239777 0.67749527
##  [563,] 0.9439794 2.47492011
##  [564,] 0.9575844 0.68077882
##  [565,] 0.3624929 0.44427009
##  [566,] 1.4629494 0.43150105
##  [567,] 1.3264054 0.63571939
##  [568,] 0.8142658 0.38121292
##  [569,] 1.4873896 0.34538661
##  [570,] 0.5646461 2.51270857
##  [571,] 0.6341621 0.53817183
##  [572,] 1.1083939 0.30669715
##  [573,] 0.6150498 0.91717872
##  [574,] 1.6645464 1.23816295
##  [575,] 1.0500696 0.66450274
##  [576,] 1.2782549 0.93115874
##  [577,] 1.1037370 0.44067859
##  [578,] 1.1434943 0.77078673
##  [579,] 1.9927430 0.65627109
##  [580,] 1.6965648 1.09416162
##  [581,] 2.3949601 0.25600695
##  [582,] 0.8676468 1.00097836
##  [583,] 0.8227882 0.68760983
##  [584,] 1.0579805 0.45818086
##  [585,] 0.5188045 0.77927346
##  [586,] 0.6421122 1.14563613
##  [587,] 0.8139279 0.81656810
##  [588,] 1.0830541 1.83863015
##  [589,] 0.6733211 0.60879297
##  [590,] 1.3895271 0.36291489
##  [591,] 0.4999828 0.46949789
##  [592,] 1.7879222 2.01939287
##  [593,] 0.6177597 0.47262324
##  [594,] 0.6148628 0.64255474
##  [595,] 1.3272003 1.29874768
##  [596,] 0.4751412 0.65582707
##  [597,] 0.7660895 0.53536143
##  [598,] 0.8077521 0.74920417
##  [599,] 0.5805485 1.10725334
##  [600,] 1.4481079 1.65856086
##  [601,] 1.4046030 0.40240739
##  [602,] 0.4953450 0.26992694
##  [603,] 1.1331911 0.14083264
##  [604,] 0.9927247 0.53409929
##  [605,] 0.9571560 0.10030099
##  [606,] 1.0129746 1.36148668
##  [607,] 1.7179633 0.35206981
##  [608,] 0.8151084 1.34386907
##  [609,] 0.8413760 0.42534431
##  [610,] 0.6377790 0.66375220
##  [611,] 0.8191810 0.52970772
##  [612,] 1.9023506 0.48877964
##  [613,] 0.7802789 0.47887425
##  [614,] 2.4613850 0.22852193
##  [615,] 0.4686850 0.49134410
##  [616,] 0.6737223 0.24847774
##  [617,] 1.1617087 0.66311744
##  [618,] 0.5184008 1.20194210
##  [619,] 1.7876153 1.76615913
##  [620,] 0.8960547 0.41573785
##  [621,] 1.2925227 1.32042010
##  [622,] 0.3982909 0.91125213
##  [623,] 0.8899894 0.44005194
##  [624,] 1.6766896 0.71973246
##  [625,] 0.9738405 1.67556380
##  [626,] 0.9273455 0.64885438
##  [627,] 1.0898526 0.53767370
##  [628,] 0.6326810 0.47543047
##  [629,] 1.0689970 0.28857325
##  [630,] 0.7174799 0.84128606
##  [631,] 0.4380022 0.53859493
##  [632,] 0.9179729 1.31036709
##  [633,] 0.9557629 2.03696109
##  [634,] 0.4129020 1.05580678
##  [635,] 0.9255665 0.62801452
##  [636,] 0.9640717 3.77254893
##  [637,] 1.2229518 2.28923646
##  [638,] 0.8493876 0.27979622
##  [639,] 0.8429713 2.48786322
##  [640,] 0.9428995 0.49591699
##  [641,] 1.2311243 1.00405630
##  [642,] 1.3371239 0.66597868
##  [643,] 1.6115904 0.71652616
##  [644,] 0.7936685 1.31472403
##  [645,] 1.3472174 0.95369391
##  [646,] 1.5562158 0.37791724
##  [647,] 0.9081296 0.63750089
##  [648,] 1.3555610 0.46566242
##  [649,] 0.8755077 0.73895344
##  [650,] 0.7565206 0.57188120
##  [651,] 1.0864264 0.38526797
##  [652,] 1.6900514 2.46313002
##  [653,] 1.3128391 0.85696827
##  [654,] 2.0886695 0.54449375
##  [655,] 1.2173470 0.77881157
##  [656,] 0.6144191 1.51594938
##  [657,] 0.8722079 0.52339553
##  [658,] 1.7895085 0.28548936
##  [659,] 0.7319295 0.36685854
##  [660,] 1.0731639 0.29275282
##  [661,] 1.5735220 1.51771568
##  [662,] 0.5998158 0.25247156
##  [663,] 0.9673169 0.40964553
##  [664,] 0.8107573 1.18693750
##  [665,] 0.6481362 0.98407053
##  [666,] 1.6743000 0.38745267
##  [667,] 0.9648410 2.19017570
##  [668,] 0.5131751 1.16605968
##  [669,] 0.3523672 0.23948661
##  [670,] 1.2296812 1.10600884
##  [671,] 1.8327304 3.01333372
##  [672,] 0.6870866 0.78943740
##  [673,] 0.4570492 0.10334894
##  [674,] 0.9469543 0.97295730
##  [675,] 0.5287070 0.18536263
##  [676,] 0.9569295 0.26886512
##  [677,] 0.7034305 0.59378886
##  [678,] 0.6948354 0.30939867
##  [679,] 1.1593642 0.96429106
##  [680,] 0.7924395 0.55386847
##  [681,] 2.2846166 0.52583126
##  [682,] 1.2412141 1.83679839
##  [683,] 0.6623534 0.82699719
##  [684,] 0.7497580 2.83027162
##  [685,] 1.0890340 0.41806337
##  [686,] 0.7644357 0.66861705
##  [687,] 0.5102281 1.15531801
##  [688,] 0.7071446 0.41778014
##  [689,] 1.1405999 0.95420451
##  [690,] 1.3334555 0.56537348
##  [691,] 0.6391468 0.54602378
##  [692,] 0.8739549 0.47264477
##  [693,] 1.0568388 1.49864765
##  [694,] 1.1336905 0.48488004
##  [695,] 0.7365517 2.24217536
##  [696,] 0.9230869 1.65079221
##  [697,] 1.0905601 0.94672782
##  [698,] 1.1795598 1.09383929
##  [699,] 1.0051969 0.42479559
##  [700,] 1.0777795 0.52569808
##  [701,] 1.4024224 0.61434260
##  [702,] 1.0928961 0.29942980
##  [703,] 0.6633120 0.52674477
##  [704,] 0.5473544 1.19450004
##  [705,] 0.7007456 0.87835904
##  [706,] 1.3874058 3.00553860
##  [707,] 2.3339984 1.94182889
##  [708,] 1.0090736 1.27585819
##  [709,] 0.9843207 1.04545019
##  [710,] 1.3670054 0.63546327
##  [711,] 0.9043073 1.17487143
##  [712,] 1.7794172 0.39463199
##  [713,] 0.6320827 0.93520007
##  [714,] 0.6201806 1.36387166
##  [715,] 0.5930943 1.19771705
##  [716,] 0.3001921 0.73074733
##  [717,] 1.0546508 1.66301178
##  [718,] 0.9732078 0.45788715
##  [719,] 0.5524058 0.92037906
##  [720,] 0.9719949 1.60898852
##  [721,] 0.9513343 1.85851504
##  [722,] 0.5649801 0.54720261
##  [723,] 0.6933109 1.58052411
##  [724,] 1.0386181 1.40522230
##  [725,] 0.3592518 0.72460665
##  [726,] 0.9732398 0.63299761
##  [727,] 1.6005340 0.89691950
##  [728,] 1.4471711 0.39826909
##  [729,] 0.9340927 0.54772939
##  [730,] 1.7672689 0.95001893
##  [731,] 1.0851706 3.21684723
##  [732,] 0.9458468 0.72029372
##  [733,] 0.9137647 0.65456881
##  [734,] 1.0489695 0.44741136
##  [735,] 0.8833131 0.40606834
##  [736,] 2.1270509 0.82461841
##  [737,] 0.9798054 1.62100014
##  [738,] 1.5036708 1.65351326
##  [739,] 0.9179852 0.48903128
##  [740,] 1.4685586 0.17455042
##  [741,] 1.5217528 2.19091294
##  [742,] 2.5295088 0.96666976
##  [743,] 1.4400232 2.74944113
##  [744,] 0.2754937 1.07558916
##  [745,] 1.4136367 0.75787824
##  [746,] 0.7458125 0.97526422
##  [747,] 0.8010617 0.61558488
##  [748,] 0.7194042 3.16194004
##  [749,] 1.5264828 0.44886260
##  [750,] 0.5849107 1.50748115
##  [751,] 0.9978633 1.33264594
##  [752,] 1.0853260 0.45133944
##  [753,] 0.5755730 1.29373341
##  [754,] 0.9971967 1.47335391
##  [755,] 0.6837862 0.61231797
##  [756,] 1.2734995 0.36464231
##  [757,] 0.7180918 2.53677232
##  [758,] 0.4171203 0.15288116
##  [759,] 1.0084313 0.34854625
##  [760,] 1.1157832 0.67956711
##  [761,] 0.6090369 1.18367333
##  [762,] 0.9315472 1.84519642
##  [763,] 0.6872027 1.03328457
##  [764,] 0.5381560 3.01672213
##  [765,] 1.1371912 0.47577435
##  [766,] 0.5191757 1.62351655
##  [767,] 1.0783111 1.35834860
##  [768,] 1.8404953 0.68162374
##  [769,] 1.4790855 0.47145633
##  [770,] 1.1336726 2.36244477
##  [771,] 0.7896720 0.64970516
##  [772,] 1.2595286 1.11470180
##  [773,] 0.6609331 0.88122653
##  [774,] 1.0474255 0.93982168
##  [775,] 1.5180339 0.74132030
##  [776,] 1.1793750 0.30940036
##  [777,] 0.9915146 2.12002583
##  [778,] 1.9800910 0.77054302
##  [779,] 0.8571571 0.43065451
##  [780,] 0.8145296 1.42305442
##  [781,] 0.9966323 0.33939985
##  [782,] 0.7629442 1.17320119
##  [783,] 0.8092177 1.15727055
##  [784,] 1.7821356 0.34297422
##  [785,] 1.2007393 0.39191767
##  [786,] 1.2640692 1.51165740
##  [787,] 1.3191344 0.36951038
##  [788,] 1.6824842 0.50778791
##  [789,] 1.0483293 0.99975486
##  [790,] 0.9481584 0.61468518
##  [791,] 1.0801105 1.85331976
##  [792,] 1.6595553 1.66029041
##  [793,] 0.6750670 0.82189094
##  [794,] 1.4277708 2.55477320
##  [795,] 0.5052926 0.86638602
##  [796,] 0.7568508 0.89539720
##  [797,] 0.9254903 0.78481270
##  [798,] 0.8061834 2.30384217
##  [799,] 1.0905237 0.12016111
##  [800,] 1.1155049 0.39650063
##  [801,] 0.4364479 0.63612399
##  [802,] 0.8036199 1.29308558
##  [803,] 1.0855896 1.00063557
##  [804,] 1.3738623 0.49616068
##  [805,] 0.5582882 0.50253861
##  [806,] 2.5741008 0.82076126
##  [807,] 1.4947854 0.29351390
##  [808,] 0.7219884 0.39720413
##  [809,] 0.9872994 0.42632975
##  [810,] 1.4559654 2.18926048
##  [811,] 0.7750348 0.28377313
##  [812,] 1.2712422 1.27437042
##  [813,] 1.3797494 0.92053095
##  [814,] 1.0756891 0.61051529
##  [815,] 1.1736942 0.51404241
##  [816,] 0.5968801 3.42378356
##  [817,] 0.7597876 2.53652540
##  [818,] 1.6796850 0.34889405
##  [819,] 0.6284838 0.43991808
##  [820,] 0.7005164 0.63074650
##  [821,] 0.7605262 0.87376904
##  [822,] 2.0667539 1.63512257
##  [823,] 0.5919147 2.22035747
##  [824,] 1.0540002 0.32149295
##  [825,] 0.9924952 0.13454243
##  [826,] 2.1866785 0.66726430
##  [827,] 0.7354532 0.63161741
##  [828,] 1.3697031 0.76839263
##  [829,] 1.0786545 2.30537317
##  [830,] 1.1063630 0.88699861
##  [831,] 1.5434348 0.41820902
##  [832,] 1.5376725 1.63860890
##  [833,] 1.9987969 0.77646859
##  [834,] 1.0783570 1.18970044
##  [835,] 1.1654868 1.43835711
##  [836,] 0.7386047 2.11747962
##  [837,] 1.2029716 0.67017458
##  [838,] 0.5871698 0.67709216
##  [839,] 1.3255574 1.72397996
##  [840,] 1.0938634 1.29652141
##  [841,] 1.1805793 0.61096820
##  [842,] 0.5785200 1.27698298
##  [843,] 0.9554876 0.74784552
##  [844,] 1.0636762 0.78541896
##  [845,] 1.6442927 0.87125920
##  [846,] 1.0503535 0.65302342
##  [847,] 1.7706599 1.87619706
##  [848,] 1.5964738 0.80080885
##  [849,] 1.1494420 0.26659935
##  [850,] 1.4584910 1.52391637
##  [851,] 1.1626891 0.51971994
##  [852,] 0.7899168 0.67771390
##  [853,] 0.5307954 1.01687541
##  [854,] 2.3350121 1.59715964
##  [855,] 2.4366556 0.32414609
##  [856,] 0.7912638 0.46361835
##  [857,] 0.7361121 2.18199538
##  [858,] 1.1374259 1.78077948
##  [859,] 1.6698829 0.93145996
##  [860,] 0.5766466 0.69464921
##  [861,] 1.1805209 0.71483301
##  [862,] 0.4513298 0.63615409
##  [863,] 0.6239327 1.38468531
##  [864,] 0.8785342 1.95369484
##  [865,] 1.1631302 0.95332698
##  [866,] 2.3500623 0.80596946
##  [867,] 0.6301218 1.37322521
##  [868,] 1.0054121 0.79205882
##  [869,] 0.8629807 0.47000307
##  [870,] 0.9475393 0.92676823
##  [871,] 0.9940869 0.59288117
##  [872,] 0.7995141 0.66042558
##  [873,] 0.6219837 0.65139214
##  [874,] 0.5528175 1.00392992
##  [875,] 1.1892717 0.30483073
##  [876,] 1.1394839 0.25203697
##  [877,] 0.8183237 1.13189390
##  [878,] 1.1087359 0.66285050
##  [879,] 1.1092426 0.77688110
##  [880,] 1.5537937 0.47180169
##  [881,] 0.8674769 1.54615937
##  [882,] 0.5308028 0.98418830
##  [883,] 1.4704199 0.44558072
##  [884,] 0.7414204 0.24001805
##  [885,] 0.6708262 0.30869066
##  [886,] 0.3522735 0.95536858
##  [887,] 1.3313829 0.46241999
##  [888,] 1.5585697 1.74000650
##  [889,] 1.5906467 0.87779129
##  [890,] 1.7081660 0.48048510
##  [891,] 1.1835719 1.37884165
##  [892,] 0.8473049 0.32947413
##  [893,] 2.4220641 0.83996681
##  [894,] 0.6607685 0.71532930
##  [895,] 0.8657316 1.04689060
##  [896,] 1.2346253 1.12529582
##  [897,] 0.6024895 0.44962065
##  [898,] 0.9667880 0.54664622
##  [899,] 0.6891826 1.40368978
##  [900,] 2.0986056 0.94174814
##  [901,] 1.1649506 0.44995976
##  [902,] 1.6165489 0.69415764
##  [903,] 0.9273213 1.12542505
##  [904,] 1.9120176 0.59919946
##  [905,] 0.7761717 0.56712705
##  [906,] 0.9388734 1.21664536
##  [907,] 1.7306979 0.71836654
##  [908,] 1.2649092 1.22847536
##  [909,] 1.2567141 0.79392398
##  [910,] 0.9811175 1.07410802
##  [911,] 1.9466242 0.48093300
##  [912,] 1.0540808 0.58661451
##  [913,] 0.8840798 0.67304908
##  [914,] 1.1711961 1.05938058
##  [915,] 0.7400387 0.63342124
##  [916,] 1.4771560 1.25702951
##  [917,] 0.9681602 0.47673990
##  [918,] 2.0620615 0.57853116
##  [919,] 1.2606227 0.37252709
##  [920,] 1.0085180 1.26622068
##  [921,] 0.8651057 2.16169726
##  [922,] 0.7543947 0.40121430
##  [923,] 1.4801757 1.00038269
##  [924,] 0.5695909 0.66893438
##  [925,] 0.2553808 0.25220561
##  [926,] 0.9831723 1.47041860
##  [927,] 0.7597769 1.14555190
##  [928,] 0.7727866 0.90998446
##  [929,] 0.7117451 0.63397771
##  [930,] 0.8481148 1.39980917
##  [931,] 0.8844150 0.75563791
##  [932,] 0.8653458 0.30062275
##  [933,] 0.6664190 0.31937871
##  [934,] 0.8847535 0.81790362
##  [935,] 1.0162156 0.51963554
##  [936,] 0.7665097 0.72483829
##  [937,] 1.4084811 1.17702961
##  [938,] 1.2802782 1.13258881
##  [939,] 1.2560090 0.32362165
##  [940,] 1.4217175 0.78303820
##  [941,] 0.5764011 2.03222221
##  [942,] 0.8274205 0.76527526
##  [943,] 2.1356664 0.39395899
##  [944,] 1.2315666 0.87672153
##  [945,] 1.0954543 0.94154121
##  [946,] 0.5468170 0.20963870
##  [947,] 1.4482587 0.49948966
##  [948,] 1.0986991 0.74451878
##  [949,] 1.3052531 0.98433816
##  [950,] 0.6548310 0.57296279
##  [951,] 0.6344438 1.48510248
##  [952,] 0.4525715 1.66001326
##  [953,] 0.6278404 0.45471767
##  [954,] 0.7434568 1.27367445
##  [955,] 0.8637666 0.54536446
##  [956,] 0.4802864 0.77908290
##  [957,] 0.9598703 0.63663256
##  [958,] 0.7106065 1.92254418
##  [959,] 0.7947417 0.92585545
##  [960,] 1.1118600 0.92369104
##  [961,] 0.6045283 1.88830095
##  [962,] 0.9722929 0.58331557
##  [963,] 0.9800335 0.95575139
##  [964,] 0.4926780 1.80634813
##  [965,] 1.8444566 2.39246354
##  [966,] 1.0776578 1.10890083
##  [967,] 1.4646987 0.51160844
##  [968,] 0.6513347 0.37531159
##  [969,] 1.7425734 1.37701317
##  [970,] 0.5335758 0.97395123
##  [971,] 1.1954757 1.26700725
##  [972,] 1.4796244 2.67054590
##  [973,] 0.9021764 3.36105509
##  [974,] 0.5981291 0.92819957
##  [975,] 0.9418252 0.28157071
##  [976,] 0.4054818 0.59302974
##  [977,] 0.8987751 0.43677421
##  [978,] 1.9708425 0.32669642
##  [979,] 1.7876944 0.54172062
##  [980,] 0.6964485 1.05258829
##  [981,] 0.8617170 0.38039154
##  [982,] 0.9849235 0.39278799
##  [983,] 1.0658202 0.56935223
##  [984,] 1.5675386 1.44378409
##  [985,] 0.5576578 0.35435288
##  [986,] 0.7127954 1.21412466
##  [987,] 0.7832856 2.13186651
##  [988,] 0.6703056 1.05546621
##  [989,] 0.8203546 1.68331851
##  [990,] 0.4691818 0.21680691
##  [991,] 0.8627759 2.01184416
##  [992,] 0.9627795 0.88596254
##  [993,] 0.4082457 0.52581014
##  [994,] 1.6207799 2.35496592
##  [995,] 1.9105943 0.64011094
##  [996,] 0.6759106 0.98933358
##  [997,] 1.0878052 0.26060779
##  [998,] 1.2342743 0.62935770
##  [999,] 1.0115883 1.09430658
## 
## $model.matrix
##     (Intercept) format_16S_L6$Group11 format_16S_L6$Group12
## 1             1                    -1                    -1
## 2             1                     1                     0
## 3             1                     0                     0
## 4             1                     0                     1
## 5             1                    -1                    -1
## 6             1                     1                     0
## 7             1                     0                     0
## 8             1                     0                     1
## 9             1                    -1                    -1
## 10            1                     1                     0
## 11            1                     0                     0
## 12            1                     0                     1
## 13            1                    -1                    -1
## 14            1                     1                     0
## 15            1                     0                     0
## 16            1                     0                     1
## 17            1                    -1                    -1
## 18            1                     1                     0
## 19            1                     0                     0
## 20            1                     0                     1
## 21            1                    -1                    -1
## 22            1                     1                     0
## 23            1                     0                     0
## 24            1                     0                     1
## 25            1                    -1                    -1
## 26            1                     1                     0
## 27            1                     0                     0
## 28            1                     0                     1
## 29            1                    -1                    -1
## 30            1                     1                     0
## 31            1                     0                     0
## 32            1                     0                     1
## 33            1                    -1                    -1
## 34            1                     1                     0
## 35            1                     0                     0
## 36            1                     0                     1
## 37            1                    -1                    -1
## 38            1                     1                     0
## 39            1                     0                     0
## 40            1                     0                     1
## 41            1                    -1                    -1
## 42            1                     1                     0
## 43            1                     0                     0
## 44            1                     0                     1
## 45            1                    -1                    -1
## 46            1                     1                     0
## 47            1                     0                     0
## 48            1                     0                     1
## 49            1                    -1                    -1
## 50            1                     1                     0
## 51            1                     0                     0
## 52            1                     0                     1
## 53            1                    -1                    -1
## 54            1                     1                     0
## 55            1                     0                     0
## 56            1                     0                     1
## 57            1                    -1                    -1
## 58            1                     1                     0
## 59            1                     0                     0
## 60            1                     0                     1
## 61            1                    -1                    -1
## 62            1                     1                     0
## 63            1                     0                     0
## 64            1                     0                     1
## 65            1                    -1                    -1
## 66            1                     1                     0
## 67            1                     0                     0
## 68            1                     0                     1
## 69            1                    -1                    -1
## 70            1                     1                     0
## 71            1                     0                     0
## 72            1                     0                     1
## 73            1                    -1                    -1
## 74            1                     1                     0
## 75            1                     0                     0
## 76            1                     0                     1
## 77            1                    -1                    -1
## 78            1                     1                     0
## 79            1                     0                     0
## 80            1                     0                     1
## 81            1                    -1                    -1
## 82            1                     1                     0
## 83            1                     0                     0
## 84            1                     0                     1
## 85            1                    -1                    -1
## 86            1                     1                     0
## 87            1                     0                     0
## 88            1                     0                     1
## 89            1                    -1                    -1
## 90            1                     1                     0
## 91            1                     0                     0
## 92            1                     0                     1
## 93            1                    -1                    -1
## 94            1                     1                     0
## 95            1                     0                     0
## 96            1                     0                     1
## 97            1                    -1                    -1
## 98            1                     1                     0
## 99            1                     0                     0
## 100           1                     0                     1
## 101           1                    -1                    -1
## 102           1                     1                     0
## 103           1                     0                     0
## 104           1                     0                     1
## 105           1                    -1                    -1
## 106           1                     1                     0
## 107           1                     0                     0
## 108           1                     0                     1
## 109           1                    -1                    -1
## 110           1                     1                     0
## 111           1                     0                     0
## 112           1                     0                     1
## 113           1                    -1                    -1
## 114           1                     1                     0
## 115           1                     0                     0
## 116           1                     0                     1
## 117           1                    -1                    -1
## 118           1                     1                     0
## 119           1                     0                     0
## 120           1                     0                     1
## 121           1                    -1                    -1
## 122           1                     1                     0
## 123           1                     0                     0
## 124           1                     0                     1
## 125           1                    -1                    -1
## 126           1                     1                     0
## 127           1                     0                     0
## 128           1                     0                     1
## 129           1                    -1                    -1
## 130           1                     1                     0
## 131           1                     0                     0
## 132           1                     0                     1
## 133           1                    -1                    -1
## 134           1                     1                     0
## 135           1                     0                     0
## 136           1                     0                     1
## 137           1                    -1                    -1
## 138           1                     1                     0
## 139           1                     0                     0
## 140           1                     0                     1
## 141           1                    -1                    -1
## 142           1                     1                     0
## 143           1                     0                     0
## 144           1                     0                     1
## 145           1                    -1                    -1
## 146           1                     1                     0
## 147           1                     0                     0
## 148           1                     0                     1
## 149           1                    -1                    -1
## 150           1                     1                     0
## 151           1                     0                     0
## 152           1                     0                     1
## 153           1                    -1                    -1
## 154           1                     1                     0
## 155           1                     0                     0
## 156           1                     0                     1
## 157           1                    -1                    -1
## 158           1                     1                     0
## 159           1                     0                     0
## 160           1                     0                     1
## 161           1                    -1                    -1
## 162           1                     1                     0
## 163           1                     0                     0
## 164           1                     0                     1
## 165           1                    -1                    -1
## 166           1                     1                     0
## 167           1                     0                     0
## 168           1                     0                     1
## 169           1                    -1                    -1
## 170           1                     1                     0
## 171           1                     0                     0
## 172           1                     0                     1
## 173           1                    -1                    -1
## 174           1                     1                     0
## 175           1                     0                     0
## 176           1                     0                     1
## 177           1                    -1                    -1
## 178           1                     1                     0
## 179           1                     0                     0
## 180           1                     0                     1
## 181           1                    -1                    -1
## 182           1                     1                     0
## 183           1                     0                     0
## 184           1                     0                     1
## 185           1                    -1                    -1
## 186           1                     1                     0
## 187           1                     0                     0
## 188           1                     0                     1
## 189           1                    -1                    -1
## 190           1                     1                     0
## 191           1                     0                     0
## 192           1                     0                     1
## 193           1                    -1                    -1
## 194           1                     1                     0
## 195           1                     0                     0
## 196           1                     0                     1
## 197           1                    -1                    -1
## 198           1                     1                     0
## 199           1                     0                     0
## 200           1                     0                     1
## 201           1                    -1                    -1
## 202           1                     1                     0
## 203           1                     0                     0
## 204           1                     0                     1
## 205           1                    -1                    -1
## 206           1                     1                     0
## 207           1                     0                     0
## 208           1                     0                     1
## 209           1                    -1                    -1
## 210           1                     1                     0
## 211           1                     0                     0
## 212           1                     0                     1
## 213           1                    -1                    -1
## 214           1                     1                     0
## 215           1                     0                     0
## 216           1                     0                     1
## 217           1                    -1                    -1
## 218           1                     1                     0
## 219           1                     0                     0
## 220           1                     0                     1
## 221           1                    -1                    -1
## 222           1                     1                     0
## 223           1                     0                     0
## 224           1                     0                     1
## 225           1                    -1                    -1
## 226           1                     1                     0
## 227           1                     0                     0
## 228           1                     0                     1
## 229           1                    -1                    -1
## 230           1                     1                     0
## 231           1                     0                     0
## 232           1                     0                     1
## 233           1                    -1                    -1
## 234           1                     1                     0
## 235           1                     0                     0
## 236           1                     0                     1
## 237           1                    -1                    -1
## 238           1                     1                     0
## 239           1                     0                     0
## 240           1                     0                     1
## 241           1                    -1                    -1
## 242           1                     1                     0
## 243           1                     0                     0
## 244           1                     0                     1
## 245           1                    -1                    -1
## 246           1                     1                     0
## 247           1                     0                     0
## 248           1                     0                     1
## 249           1                    -1                    -1
## 250           1                     1                     0
## 251           1                     0                     0
## 252           1                     0                     1
## 253           1                    -1                    -1
## 254           1                     1                     0
## 255           1                     0                     0
## 256           1                     0                     1
## 257           1                    -1                    -1
## 258           1                     1                     0
## 259           1                     0                     0
## 260           1                     0                     1
## 261           1                    -1                    -1
## 262           1                     1                     0
## 263           1                     0                     0
## 264           1                     0                     1
## 265           1                    -1                    -1
## 266           1                     1                     0
## 267           1                     0                     0
## 268           1                     0                     1
## 269           1                    -1                    -1
## 270           1                     1                     0
## 271           1                     0                     0
## 272           1                     0                     1
## 273           1                    -1                    -1
## 274           1                     1                     0
## 275           1                     0                     0
## 276           1                     0                     1
## 277           1                    -1                    -1
## 278           1                     1                     0
## 279           1                     0                     0
## 280           1                     0                     1
## 281           1                    -1                    -1
## 282           1                     1                     0
## 283           1                     0                     0
## 284           1                     0                     1
## 285           1                    -1                    -1
## 286           1                     1                     0
## 287           1                     0                     0
## 288           1                     0                     1
## 289           1                    -1                    -1
## 290           1                     1                     0
## 291           1                     0                     0
## 292           1                     0                     1
## 293           1                    -1                    -1
## 294           1                     1                     0
## 295           1                     0                     0
## 296           1                     0                     1
## 297           1                    -1                    -1
## 298           1                     1                     0
## 299           1                     0                     0
## 300           1                     0                     1
## 301           1                    -1                    -1
## 302           1                     1                     0
## 303           1                     0                     0
## 304           1                     0                     1
## 305           1                    -1                    -1
## 306           1                     1                     0
## 307           1                     0                     0
## 308           1                     0                     1
## 309           1                    -1                    -1
## 310           1                     1                     0
## 311           1                     0                     0
## 312           1                     0                     1
## 313           1                    -1                    -1
## 314           1                     1                     0
## 315           1                     0                     0
## 316           1                     0                     1
## 317           1                    -1                    -1
## 318           1                     1                     0
## 319           1                     0                     0
## 320           1                     0                     1
##     format_16S_L6$Group13 dph
## 1                      -1   1
## 2                       0   1
## 3                       1   1
## 4                       0   1
## 5                      -1   1
## 6                       0   1
## 7                       1   1
## 8                       0   1
## 9                      -1   1
## 10                      0   1
## 11                      1   1
## 12                      0   1
## 13                     -1   1
## 14                      0   1
## 15                      1   1
## 16                      0   1
## 17                     -1   1
## 18                      0   1
## 19                      1   1
## 20                      0   1
## 21                     -1   1
## 22                      0   1
## 23                      1   1
## 24                      0   1
## 25                     -1   1
## 26                      0   1
## 27                      1   1
## 28                      0   1
## 29                     -1   1
## 30                      0   1
## 31                      1   1
## 32                      0   1
## 33                     -1   1
## 34                      0   1
## 35                      1   1
## 36                      0   1
## 37                     -1   1
## 38                      0   1
## 39                      1   1
## 40                      0   1
## 41                     -1   4
## 42                      0   4
## 43                      1   4
## 44                      0   4
## 45                     -1   4
## 46                      0   4
## 47                      1   4
## 48                      0   4
## 49                     -1   4
## 50                      0   4
## 51                      1   4
## 52                      0   4
## 53                     -1   4
## 54                      0   4
## 55                      1   4
## 56                      0   4
## 57                     -1   4
## 58                      0   4
## 59                      1   4
## 60                      0   4
## 61                     -1   4
## 62                      0   4
## 63                      1   4
## 64                      0   4
## 65                     -1   4
## 66                      0   4
## 67                      1   4
## 68                      0   4
## 69                     -1   4
## 70                      0   4
## 71                      1   4
## 72                      0   4
## 73                     -1   4
## 74                      0   4
## 75                      1   4
## 76                      0   4
## 77                     -1   4
## 78                      0   4
## 79                      1   4
## 80                      0   4
## 81                     -1   7
## 82                      0   7
## 83                      1   7
## 84                      0   7
## 85                     -1   7
## 86                      0   7
## 87                      1   7
## 88                      0   7
## 89                     -1   7
## 90                      0   7
## 91                      1   7
## 92                      0   7
## 93                     -1   7
## 94                      0   7
## 95                      1   7
## 96                      0   7
## 97                     -1   7
## 98                      0   7
## 99                      1   7
## 100                     0   7
## 101                    -1   7
## 102                     0   7
## 103                     1   7
## 104                     0   7
## 105                    -1   7
## 106                     0   7
## 107                     1   7
## 108                     0   7
## 109                    -1   7
## 110                     0   7
## 111                     1   7
## 112                     0   7
## 113                    -1   7
## 114                     0   7
## 115                     1   7
## 116                     0   7
## 117                    -1   7
## 118                     0   7
## 119                     1   7
## 120                     0   7
## 121                    -1  14
## 122                     0  14
## 123                     1  14
## 124                     0  14
## 125                    -1  14
## 126                     0  14
## 127                     1  14
## 128                     0  14
## 129                    -1  14
## 130                     0  14
## 131                     1  14
## 132                     0  14
## 133                    -1  14
## 134                     0  14
## 135                     1  14
## 136                     0  14
## 137                    -1  14
## 138                     0  14
## 139                     1  14
## 140                     0  14
## 141                    -1  14
## 142                     0  14
## 143                     1  14
## 144                     0  14
## 145                    -1  14
## 146                     0  14
## 147                     1  14
## 148                     0  14
## 149                    -1  14
## 150                     0  14
## 151                     1  14
## 152                     0  14
## 153                    -1  14
## 154                     0  14
## 155                     1  14
## 156                     0  14
## 157                    -1  14
## 158                     0  14
## 159                     1  14
## 160                     0  14
## 161                    -1  21
## 162                     0  21
## 163                     1  21
## 164                     0  21
## 165                    -1  21
## 166                     0  21
## 167                     1  21
## 168                     0  21
## 169                    -1  21
## 170                     0  21
## 171                     1  21
## 172                     0  21
## 173                    -1  21
## 174                     0  21
## 175                     1  21
## 176                     0  21
## 177                    -1  21
## 178                     0  21
## 179                     1  21
## 180                     0  21
## 181                    -1  21
## 182                     0  21
## 183                     1  21
## 184                     0  21
## 185                    -1  21
## 186                     0  21
## 187                     1  21
## 188                     0  21
## 189                    -1  21
## 190                     0  21
## 191                     1  21
## 192                     0  21
## 193                    -1  21
## 194                     0  21
## 195                     1  21
## 196                     0  21
## 197                    -1  21
## 198                     0  21
## 199                     1  21
## 200                     0  21
## 201                    -1  28
## 202                     0  28
## 203                     1  28
## 204                     0  28
## 205                    -1  28
## 206                     0  28
## 207                     1  28
## 208                     0  28
## 209                    -1  28
## 210                     0  28
## 211                     1  28
## 212                     0  28
## 213                    -1  28
## 214                     0  28
## 215                     1  28
## 216                     0  28
## 217                    -1  28
## 218                     0  28
## 219                     1  28
## 220                     0  28
## 221                    -1  28
## 222                     0  28
## 223                     1  28
## 224                     0  28
## 225                    -1  28
## 226                     0  28
## 227                     1  28
## 228                     0  28
## 229                    -1  28
## 230                     0  28
## 231                     1  28
## 232                     0  28
## 233                    -1  28
## 234                     0  28
## 235                     1  28
## 236                     0  28
## 237                    -1  28
## 238                     0  28
## 239                     1  28
## 240                     0  28
## 241                    -1  35
## 242                     0  35
## 243                     1  35
## 244                     0  35
## 245                    -1  35
## 246                     0  35
## 247                     1  35
## 248                     0  35
## 249                    -1  35
## 250                     0  35
## 251                     1  35
## 252                     0  35
## 253                    -1  35
## 254                     0  35
## 255                     1  35
## 256                     0  35
## 257                    -1  35
## 258                     0  35
## 259                     1  35
## 260                     0  35
## 261                    -1  35
## 262                     0  35
## 263                     1  35
## 264                     0  35
## 265                    -1  35
## 266                     0  35
## 267                     1  35
## 268                     0  35
## 269                    -1  35
## 270                     0  35
## 271                     1  35
## 272                     0  35
## 273                    -1  35
## 274                     0  35
## 275                     1  35
## 276                     0  35
## 277                    -1  35
## 278                     0  35
## 279                     1  35
## 280                     0  35
## 281                    -1  42
## 282                     0  42
## 283                     1  42
## 284                     0  42
## 285                    -1  42
## 286                     0  42
## 287                     1  42
## 288                     0  42
## 289                    -1  42
## 290                     0  42
## 291                     1  42
## 292                     0  42
## 293                    -1  42
## 294                     0  42
## 295                     1  42
## 296                     0  42
## 297                    -1  42
## 298                     0  42
## 299                     1  42
## 300                     0  42
## 301                    -1  42
## 302                     0  42
## 303                     1  42
## 304                     0  42
## 305                    -1  42
## 306                     0  42
## 307                     1  42
## 308                     0  42
## 309                    -1  42
## 310                     0  42
## 311                     1  42
## 312                     0  42
## 313                    -1  42
## 314                     0  42
## 315                     1  42
## 316                     0  42
## 317                    -1  42
## 318                     0  42
## 319                     1  42
## 320                     0  42
## 
## $terms
## format_16S_L6[, 1:529] ~ format_16S_L6$Group1 + dph
## attr(,"variables")
## list(format_16S_L6[, 1:529], format_16S_L6$Group1, dph)
## attr(,"factors")
##                        format_16S_L6$Group1 dph
## format_16S_L6[, 1:529]                    0   0
## format_16S_L6$Group1                      1   0
## dph                                       0   1
## attr(,"term.labels")
## [1] "format_16S_L6$Group1" "dph"                 
## attr(,"order")
## [1] 1 1
## attr(,"intercept")
## [1] 1
## attr(,"response")
## [1] 1
## attr(,".Environment")
## <environment: R_GlobalEnv>
## 
## attr(,"class")
## [1] "adonis"
set.seed(1234)
adonis(format_16S_L6_AA[,1:529]~ format_16S_L6_AA$Group1 + dph)
## 'adonis' will be deprecated: use 'adonis2' instead
## $aov.tab
## Permutation: free
## Number of permutations: 999
## 
## Terms added sequentially (first to last)
## 
##                          Df SumsOfSqs MeanSqs F.Model      R2 Pr(>F)    
## format_16S_L6_AA$Group1   3    34.278 11.4262  41.635 0.27479  0.001 ***
## dph                       1     4.016  4.0162  14.634 0.03220  0.001 ***
## Residuals               315    86.448  0.2744         0.69301           
## Total                   319   124.742                 1.00000           
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## $call
## adonis(formula = format_16S_L6_AA[, 1:529] ~ format_16S_L6_AA$Group1 + 
##     dph)
## 
## $coefficients
##                          Granulicella Bryobacter         X__ Blastocatella
## (Intercept)                 584.13518   349.0126  110.504452     89292.357
## format_16S_L6_AA$Group11    813.14296  7776.3256  721.482616    -60390.231
## format_16S_L6_AA$Group12   -239.21131 -2592.1085 -240.494205    -60390.231
## format_16S_L6_AA$Group13   -286.96582 -2592.1085 -240.494205    -60390.231
## dph                         -15.64049   118.0577    6.841566     -1521.165
##                           uncultured        RB41       X__.1
## (Intercept)               215461.435  4343.26168  368.293123
## format_16S_L6_AA$Group11 -266474.111  3925.00525  558.087565
## format_16S_L6_AA$Group12 -266474.111 -3119.86193 -186.029188
## format_16S_L6_AA$Group13 -266474.111  2314.71860 -186.029188
## dph                         2684.878   -64.38946   -9.592839
##                          uncultured.bacterium      X__.2 uncultured.bacterium.1
## (Intercept)                        920.658891  1918.6729             289.336652
## format_16S_L6_AA$Group11          3304.557649  7118.8146             426.990250
## format_16S_L6_AA$Group12         -1101.519216 -2372.9382            -142.330083
## format_16S_L6_AA$Group13         -1101.519216 -2372.9382            -142.330083
## dph                                  9.518964    23.9087              -7.737188
##                                X__.3 bacterium.YC.LK.LKJ36      X__.4
## (Intercept)               2326.64105            -1313029.7 -784390.34
## format_16S_L6_AA$Group11  6129.33690             3282058.2 1978124.14
## format_16S_L6_AA$Group12 -2043.11230            -1094019.4 -659374.71
## format_16S_L6_AA$Group13 -2043.11230            -1094019.4 -659374.71
## dph                        -14.92257              126686.8   75987.63
##                          uncultured.Acidimicrobidae.bacterium
## (Intercept)                                         1398.4404
## format_16S_L6_AA$Group11                            2866.0301
## format_16S_L6_AA$Group12                            -955.3434
## format_16S_L6_AA$Group13                            -955.3434
## dph                                                  -23.3209
##                          uncultured.Actinomycetales.bacterium      X__.5
## (Intercept)                                        -464.55228  223.79252
## format_16S_L6_AA$Group11                           1782.31542 1353.98623
## format_16S_L6_AA$Group12                           -594.10514 -451.32874
## format_16S_L6_AA$Group13                           -594.10514 -451.32874
## dph                                                  55.71881   11.97559
##                          CL500.29.marine.group uncultured.bacterium.2
## (Intercept)                         -1290.9990              565.61424
## format_16S_L6_AA$Group11             3223.4377              828.41610
## format_16S_L6_AA$Group12            -1074.4792             -276.13870
## format_16S_L6_AA$Group13            -1074.4792             -276.13870
## dph                                   124.4989              -15.23555
##                          uncultured.Acidimicrobiales.bacterium Actinomyces
## (Intercept)                                          778.00905  1085.23410
## format_16S_L6_AA$Group11                            1074.32794  8093.00320
## format_16S_L6_AA$Group12                            -358.10931 -2697.66773
## format_16S_L6_AA$Group13                            -358.10931 -2697.66773
## dph                                                  -22.09999    84.86493
##                          Aeriscardovia Bifidobacterium Gardnerella
## (Intercept)                 273462.443      11265315.6  2424877.36
## format_16S_L6_AA$Group11   -175536.272      -5889802.2 -1733098.70
## format_16S_L6_AA$Group12   -175536.272      -8890711.3 -1737066.13
## format_16S_L6_AA$Group13   -175536.272      -7904107.7 -1737066.13
## dph                          -5154.009       -121879.5   -36200.59
##                          Corynebacterium.1 Lawsonella Mycobacterium   Nocardia
## (Intercept)                    1499967.753 127680.017     667.41767  2180.1915
## format_16S_L6_AA$Group11      -1323179.485 -46540.513    3078.81933  8089.1218
## format_16S_L6_AA$Group12      -1229689.296 -57141.270   -1071.76582 -2696.3739
## format_16S_L6_AA$Group13       1543494.769 -57141.270    -935.28768 -2696.3739
## dph                              -4793.449  -3712.566      21.28148    27.1675
##                           Rhodococcus Jatrophihabitans Blastococcus
## (Intercept)               1071.755612        1169.8009   18127.6440
## format_16S_L6_AA$Group11  3336.374873       10504.7760   29374.5533
## format_16S_L6_AA$Group12 -1112.124958       -3501.5920   -9791.5178
## format_16S_L6_AA$Group13 -1112.124958       -3501.5920   -9791.5178
## dph                          2.124702         122.7258    -438.7435
##                          Geodermatophilus Modestobacter  hgcI.clade
## (Intercept)                   2621.838066      791.0968  156273.607
## format_16S_L6_AA$Group11      8295.168157     1056.4025 -115798.439
## format_16S_L6_AA$Group12     -2765.056052     -352.1342 -113707.096
## format_16S_L6_AA$Group13     -2765.056052     -352.1342  345464.764
## dph                              7.537789      -23.1033   -2121.809
##                          Brevibacterium Brachybacterium    Yimella Arthrobacter
## (Intercept)                  15687.7734      32811.5566 222.557747   2921.93588
## format_16S_L6_AA$Group11     -7322.4846     -18480.8406 245.204696  10841.20136
## format_16S_L6_AA$Group12     -7268.2490     -13562.0330 -81.734899  -3613.73379
## format_16S_L6_AA$Group13     21913.2182      50523.7143 -81.734899  -3613.73379
## dph                           -440.2784       -754.2482  -7.411729     36.41042
##                             Kocuria Paenarthrobacter Pseudarthrobacter
## (Intercept)              -15054.835       22151.2925         -5639.493
## format_16S_L6_AA$Group11 -21231.579       89771.6904        260332.062
## format_16S_L6_AA$Group12  34152.952      -29923.8968       -206626.642
## format_16S_L6_AA$Group13  11401.946      -29923.8968       -127109.375
## dph                        2072.534         409.0844         11440.271
##                              Rothia        X__.6        X__.7 Dactylosporangium
## (Intercept)              -395445.26  11347.76527  1329.727569        478.756417
## format_16S_L6_AA$Group11 -578285.87   5177.72926  3604.623360       1776.320537
## format_16S_L6_AA$Group12 -569475.91 -10891.51398 -1201.541120       -592.106846
## format_16S_L6_AA$Group13  555406.39  18940.98408 -1201.541120       -592.106846
## dph                        53528.35     98.91758    -6.746655          5.965812
##                          uncultured.1       X__.8   Kribbella Nocardioides
## (Intercept)                -802.02443  -649513.10  5463.89953   -454963.83
## format_16S_L6_AA$Group11   2060.62873  2256230.19  7443.86455   1208702.13
## format_16S_L6_AA$Group12   -686.87624 -1053115.64 -3649.45322   -402326.76
## format_16S_L6_AA$Group13   -686.87624 -1053115.64  -144.95811   -403187.68
## dph                          78.36319    89612.04   -95.49717     45165.87
##                               X__.9 Cutibacterium Microlunatus Amycolatopsis
## (Intercept)               3356.0676     -93435.70   394.610533    3089.59244
## format_16S_L6_AA$Group11  4133.4814     508161.34  1027.824609    5987.44968
## format_16S_L6_AA$Group12 -1377.8271    -175004.60  -342.608203   -1995.81656
## format_16S_L6_AA$Group13 -1377.8271    -145974.24  -342.608203   -1995.81656
## dph                       -104.1179      14769.38    -2.736965     -57.56715
##                          Lechevalieria Pseudonocardia Streptomyces Nonomuraea
## (Intercept)                 -821.53167     46940.6045   7430.37174   882.0290
## format_16S_L6_AA$Group11    2110.90092    -54619.3728  27107.67124  9002.1401
## format_16S_L6_AA$Group12    -703.63364    -57759.7996  -9035.89041 -3000.7134
## format_16S_L6_AA$Group13    -703.63364    -57759.7996  -9035.89041 -3000.7134
## dph                           80.27186       569.4313     84.50098   111.5097
##                          Actinomadura     X__.10   Atopobium
## (Intercept)                  671.8505   611.7761  114545.494
## format_16S_L6_AA$Group11   13158.5392  9673.0503 -135505.080
## format_16S_L6_AA$Group12   -4386.1797 -3119.3999 -135505.080
## format_16S_L6_AA$Group13   -4386.1797 -3276.8252 -135505.080
## dph                          195.4910   140.2657    1103.136
##                          Coriobacteriaceae.UCG.002   Olsenella Collinsella
## (Intercept)                             1334.29130  596.389880   823773.00
## format_16S_L6_AA$Group11                4950.59482 1299.886979  -267950.39
## format_16S_L6_AA$Group12               -1650.19827 -433.295660 -1198922.32
## format_16S_L6_AA$Group13               -1650.19827 -433.295660 -1151107.95
## dph                                       16.62668   -8.583906    20251.54
##                           CHKCI002 Eggerthella Enterorhabdus Gordonibacter
## (Intercept)               54219029   -90.04474     251339.64    253240.016
## format_16S_L6_AA$Group11 -41013721  1219.33899    -693279.81   -330092.327
## format_16S_L6_AA$Group12 -40972136  -406.44633    -693279.81   -329068.538
## format_16S_L6_AA$Group13 -40480759  -406.44633    -693279.81   -330092.327
## dph                        -694889    26.13111      23260.01      4044.858
##                              X__.11 uncultured.bacterium.3
## (Intercept)              -418107.50              5945.3076
## format_16S_L6_AA$Group11 -944592.19             44121.3305
## format_16S_L6_AA$Group12 -944592.19            -15730.3867
## format_16S_L6_AA$Group13 -944592.19            -12590.7603
## dph                        71721.04               518.6777
##                          uncultured.bacterium.4
## (Intercept)                           143.35414
## format_16S_L6_AA$Group11             3214.10819
## format_16S_L6_AA$Group12            -1071.36940
## format_16S_L6_AA$Group13            -1071.36940
## dph                                    48.84291
##                          uncultured.Actinomycetales.bacterium.1     X__.12
## (Intercept)                                           697.81427  4484.7006
## format_16S_L6_AA$Group11                             1166.86972  7293.1638
## format_16S_L6_AA$Group12                             -388.95657 -2431.0546
## format_16S_L6_AA$Group13                             -388.95657 -2431.0546
## dph                                                   -16.25567  -108.0866
##                              X__.13 Rubrobacter uncultured.bacterium.5
## (Intercept)              -804228.43   21403.641              2270.8168
## format_16S_L6_AA$Group11 2023582.28   86039.588              8817.3326
## format_16S_L6_AA$Group12 -674527.43  -28679.863             -2520.1444
## format_16S_L6_AA$Group13 -674527.43  -28679.863             -3148.5941
## dph                        77829.26     382.959                46.1988
##                               X__.14 metagenome
## (Intercept)               1563.42062 -173.62318
## format_16S_L6_AA$Group11  5686.12863 1137.85741
## format_16S_L6_AA$Group12 -1895.37621 -379.28580
## format_16S_L6_AA$Group13 -1895.37621 -379.28580
## dph                         17.47135   29.10047
##                          uncultured.Rubrobacteraceae.bacterium
## (Intercept)                                         2282.81894
## format_16S_L6_AA$Group11                            2825.64780
## format_16S_L6_AA$Group12                            -918.53994
## format_16S_L6_AA$Group13                            -953.55393
## dph                                                  -69.96132
##                          uncultured.Solirubrobacter.sp.    X__.15 Conexibacter
## (Intercept)                                  3362.28289 -923142.8    811.93807
## format_16S_L6_AA$Group11                    11300.75603 2316955.1   1400.54844
## format_16S_L6_AA$Group12                    -3766.91868 -772318.4   -466.84948
## format_16S_L6_AA$Group13                    -3766.91868 -772318.4   -466.84948
## dph                                            21.29662   89234.8    -18.16256
##                          Parviterribacter     X__.16       X__.17 Bacteroides
## (Intercept)                    3740.96595  2601.4950  302.2748159   676939568
## format_16S_L6_AA$Group11       6545.34612  6495.6984  944.0945628 -1422923180
## format_16S_L6_AA$Group12      -2181.78204 -2133.1432 -314.6981876 -1435594310
## format_16S_L6_AA$Group13      -2181.78204 -2181.2776 -314.6981876 -1386717191
## dph                             -82.06231   -22.1167    0.6538617    40264986
##                          Barnesiella Coprobacter uncultured.2 Dysgonomonas
## (Intercept)                420049085    14180743     26902478   8167.19513
## format_16S_L6_AA$Group11 -1157149955   -40993936   -384503263  29215.65345
## format_16S_L6_AA$Group12 -1152791572   -41071355   -380144820  -9738.55115
## format_16S_L6_AA$Group13 -1129721371   -40950447   -366314592  -9738.55115
## dph                         38802140     1415496     18822760     82.70295
##                          Butyricimonas Odoribacter Muribaculum metagenome.1
## (Intercept)                   8646.458    40603954    1706.000   -123391.46
## format_16S_L6_AA$Group11      9578.891  -143561418   53975.893    322652.31
## format_16S_L6_AA$Group12     -3192.964  -143551943  -17991.964   -176867.59
## format_16S_L6_AA$Group13     -3192.964  -142651442  -17991.964   -176867.59
## dph                           -287.026     5428865     857.156     15803.11
##                          uncultured.Bacteroidales.bacterium
## (Intercept)                                        33794.21
## format_16S_L6_AA$Group11                          728625.58
## format_16S_L6_AA$Group12                         -323994.66
## format_16S_L6_AA$Group13                         -316592.68
## dph                                                15317.59
##                          uncultured.bacterium.6 uncultured.organism      X__.18
## (Intercept)                            34517487           7145.2305  211719.516
## format_16S_L6_AA$Group11             -264574656          34638.3154  647516.747
## format_16S_L6_AA$Group12             -264619691         -11514.2688 -397513.123
## format_16S_L6_AA$Group13             -252886015         -11562.0233 -396005.009
## dph                                    12176605            232.4628    9868.153
##                          Alloprevotella Paraprevotella Prevotella Prevotella.2
## (Intercept)                     705.810     20231.5628  748346.66   52513.4327
## format_16S_L6_AA$Group11     -74551.248     43689.2364 -446239.27  -26944.5830
## format_16S_L6_AA$Group12    -149345.358    -14563.0788 -446239.27  -29544.0566
## format_16S_L6_AA$Group13    -147674.355    -14563.0788 -446239.27  -43018.4191
## dph                            7827.323      -298.3413  -15900.39    -499.7376
##                          Prevotella.6 Prevotella.7 Prevotella.9
## (Intercept)                -31130.240   492.797187    6846862.5
## format_16S_L6_AA$Group11   -54595.793  1745.671299    6317732.2
## format_16S_L6_AA$Group12   -54595.793  -581.890433   -9821541.0
## format_16S_L6_AA$Group13   -54595.793  -581.890433   -9804524.0
## dph                          4511.896     4.689118     159342.9
##                          Prevotellaceae.NK3B31.group Prevotellaceae.UCG.001
## (Intercept)                                 3623.031              97523.022
## format_16S_L6_AA$Group11                   -1308.785             406329.317
## format_16S_L6_AA$Group12                   -1330.567            -135808.237
## format_16S_L6_AA$Group13                    3969.919            -133218.180
## dph                                         -120.656               2093.678
##                            Alistipes  Rikenella Rikenellaceae.RC9.gut.group
## (Intercept)               1230771043   28119495                   61850.308
## format_16S_L6_AA$Group11 -2755920789 -320115348                  197278.919
## format_16S_L6_AA$Group12 -2754020451 -318677952                 -110379.704
## format_16S_L6_AA$Group13 -2720548400 -313089996                  -98751.665
## dph                         80401211   15372645                    2556.474
##                          uncultured.bacterium.7 Parabacteroides      X__.19
## (Intercept)                           1875.4379        35995924  20809187.5
## format_16S_L6_AA$Group11             10560.2300      -120366964 -29240358.4
## format_16S_L6_AA$Group12             -3065.6891      -120820143 -29240858.6
## format_16S_L6_AA$Group13             -3747.2704      -116746249 -29241314.5
## dph                                     98.5175         4519752    443796.2
##                          Chitinophaga Ferruginibacter Pseudoflavitalea
## (Intercept)                  2772.349       611.00707        -898.2580
## format_16S_L6_AA$Group11    79077.904       -45.36203        3339.4438
## format_16S_L6_AA$Group12   -26359.301      -276.64507       -1113.1479
## format_16S_L6_AA$Group13   -26359.301       598.65216       -1113.1479
## dph                          1241.419       -17.59800         105.8635
##                          Sediminibacterium Terrimonas Vibrionimonas
## (Intercept)                      5084.5481  790.62015    1613.95362
## format_16S_L6_AA$Group11        15700.8001 1247.19047    4003.62320
## format_16S_L6_AA$Group12        -4367.3687 -415.73016   -1237.93226
## format_16S_L6_AA$Group13        -5666.7157 -415.73016   -1382.84547
## dph                                30.6404  -19.73105     -12.16359
##                          uncultured.3 Candidatus.Aquirestis uncultured.4
## (Intercept)                 -11.49765             429.51183   1497.54675
## format_16S_L6_AA$Group11   1223.65949            2024.91383   2300.81640
## format_16S_L6_AA$Group12   -407.88650            -674.97128   -766.93880
## format_16S_L6_AA$Group13   -407.88650            -674.97128   -766.93880
## dph                          22.07285              12.91892    -38.45305
##                              X__.20 Rhodocytophaga Hymenobacter Ohtaekwangia
## (Intercept)                710.7086     1051.83662   286.640427   1761.23166
## format_16S_L6_AA$Group11 15390.0726     4054.21370   976.420198   2446.01144
## format_16S_L6_AA$Group12 -5130.0242    -1351.40457  -325.473399   -815.33715
## format_16S_L6_AA$Group13 -5130.0242    -1351.40457  -325.473399   -815.33715
## dph                        232.5956       15.76673     2.043841    -49.78392
##                           Arcicella    Emticicia Lacihabitans   Spirosoma
## (Intercept)               282.91848  1258.226279    519.53540  73120.8025
## format_16S_L6_AA$Group11 1977.90012  4127.118201   5790.57722 -90432.8929
## format_16S_L6_AA$Group12 -659.30004 -1375.706067  -1930.19241 -90432.8929
## format_16S_L6_AA$Group13 -659.30004 -1375.706067  -1930.19241 -90432.8929
## dph                        19.80956     6.183147     74.24511    911.1626
##                          Flavobacterium Chryseobacterium Cloacibacterium
## (Intercept)                  -124185.41        1946.0037      -103.39953
## format_16S_L6_AA$Group11      477445.07        -798.9281       374.32814
## format_16S_L6_AA$Group12     -160087.64        2396.7842      -124.77605
## format_16S_L6_AA$Group13     -156636.36        -798.9281      -124.77605
## dph                            14995.08         -60.3724        12.00924
##                          uncultured.bacterium.8 Olivibacter  Pedobacter
## (Intercept)                           1055.1978   -435.0058  1717.00088
## format_16S_L6_AA$Group11              1467.5691  19748.7238  8570.24013
## format_16S_L6_AA$Group12              -489.1897  -7360.9499 -2722.85311
## format_16S_L6_AA$Group13              -489.1897  -5026.8240 -2923.69351
## dph                                    -29.7899    410.3135    63.51014
##                          uncultured.Bacteroidetes.bacterium     X__.21
## (Intercept)                                       333.95795  611.52644
## format_16S_L6_AA$Group11                          411.31739  605.31250
## format_16S_L6_AA$Group12                         -137.10580 -103.19048
## format_16S_L6_AA$Group13                         -137.10580 -251.06101
## dph                                               -10.36064  -18.97186
##                          uncultured.5    FFCH7168 uncultured.bacterium.9
## (Intercept)                 827.00559   87911.157             1604.31714
## format_16S_L6_AA$Group11   7948.44374 -108725.013             5769.10607
## format_16S_L6_AA$Group12  -2649.48125 -108725.013            -1923.03536
## format_16S_L6_AA$Group13  -2649.48125 -108725.013            -1923.03536
## dph                          95.91977    1095.466               16.77464
##                          uncultured.Chloroflexi.bacterium
## (Intercept)                                    559.809349
## format_16S_L6_AA$Group11                      1506.200058
## format_16S_L6_AA$Group12                      -502.066686
## format_16S_L6_AA$Group13                      -502.066686
## dph                                             -3.039088
##                          uncultured.bacterium.10 uncultured.bacterium.11
## (Intercept)                            7858.1299               547.64642
## format_16S_L6_AA$Group11               9744.8037               779.98598
## format_16S_L6_AA$Group12              -3248.2679              -259.99533
## format_16S_L6_AA$Group13              -3248.2679              -259.99533
## dph                                    -242.6243               -15.13953
##                          gut.metagenome uncultured.bacterium.12
## (Intercept)                   -982567.6                  533681
## format_16S_L6_AA$Group11     -1369973.1               -30071666
## format_16S_L6_AA$Group12     -1368716.5               -30056021
## format_16S_L6_AA$Group13     -1361930.1               -29684406
## dph                            123817.9                 1554684
##                          uncultured.rumen.bacterium      X__.22
## (Intercept)                               1956872.0   3957493.9
## format_16S_L6_AA$Group11                -18943741.4 -12377722.7
## format_16S_L6_AA$Group12                -18925548.9 -12378015.5
## format_16S_L6_AA$Group13                -18771034.5 -12324495.2
## dph                                        894045.8    443286.4
##                          Chroococcidiopsis.SAG.2023 uncultured.6 uncultured.7
## (Intercept)                              152085.376   597824.645    1047389.9
## format_16S_L6_AA$Group11                -188093.129  -739365.682    -708371.0
## format_16S_L6_AA$Group12                -188093.129  -739365.682    -708371.0
## format_16S_L6_AA$Group13                -188093.129  -739365.682    -708371.0
## dph                                        1895.145     7449.528     -17843.1
##                          Mastigocladopsis.PCC.10914 Scytonema.UTEX.2349
## (Intercept)                              105646.123           592407.28
## format_16S_L6_AA$Group11                -130658.912          -400657.05
## format_16S_L6_AA$Group12                -130658.912          -400657.05
## format_16S_L6_AA$Group13                -130658.912          -400657.05
## dph                                        1316.463           -10092.12
##                               X__.23 uncultured.cyanobacterium Mucispirillum
## (Intercept)               244911.797                186715.046     9650.2462
## format_16S_L6_AA$Group11 -165638.813               -126279.171    72501.9987
## format_16S_L6_AA$Group12 -165638.813               -126279.171   -23991.6320
## format_16S_L6_AA$Group13 -165638.813               -126279.171   -24255.1833
## dph                        -4172.262                 -3180.836      768.6809
##                          Meiothermus    Thermus     X__.24
## (Intercept)                625.68539 -75904.135  532.97087
## format_16S_L6_AA$Group11   992.39796 219680.871  938.25051
## format_16S_L6_AA$Group12  -241.53692 -67928.263 -312.75017
## format_16S_L6_AA$Group13  -375.43052 -75876.304 -312.75017
## dph                        -13.17131   7988.444  -11.59056
##                          uncultured.bacterium.13 uncultured.bacterium.14
## (Intercept)                            716.75110               685.20886
## format_16S_L6_AA$Group11              1102.82574               956.72186
## format_16S_L6_AA$Group12              -367.60858              -318.90729
## format_16S_L6_AA$Group13              -367.60858              -318.90729
## dph                                    -18.37592               -19.27903
##                          Campylobacter Helicobacter Sulfuricurvum Sulfurimonas
## (Intercept)                  -983322.1    204897166     689.99374   1303.23177
## format_16S_L6_AA$Group11   -10963786.6   -708546184    3391.06351   1798.61387
## format_16S_L6_AA$Group12    -7718624.2   -857816716   -1130.35450   -599.53796
## format_16S_L6_AA$Group13    -9946832.3   -277927537   -1130.35450   -599.53796
## dph                           630595.4     37176083      23.17688    -37.03652
##                          Tumebacillus   Bacillus     X__.25 Exiguobacterium
## (Intercept)                189.042493  624310862 12957504.5       321.96864
## format_16S_L6_AA$Group11   334.717667 -384442171 -6229360.3      -608.93020
## format_16S_L6_AA$Group12  -111.572556 -384649010 -6229360.3      1826.79060
## format_16S_L6_AA$Group13  -111.572556 -384194544 -6229360.3      -608.93020
## dph                         -4.077365  -12613149  -354112.9        15.10324
##                          Paenibacillus Paenisporosarcina Planococcus
## (Intercept)                   692.1770         -99060.72   -88.13334
## format_16S_L6_AA$Group11      905.4887         826411.27  1216.57081
## format_16S_L6_AA$Group12     -301.8296        -274724.32  -405.52360
## format_16S_L6_AA$Group13     -301.8296        -275843.47  -405.52360
## dph                           -20.5446          19731.80    25.98194
##                          Planomicrobium Jeotgalicoccus Macrococcus
## (Intercept)                   345.59951     207.223941   540460.76
## format_16S_L6_AA$Group11     1407.22273     255.226178  -227526.48
## format_16S_L6_AA$Group12     -469.07424     -85.075393  -242754.43
## format_16S_L6_AA$Group13     -469.07424     -85.075393   166089.08
## dph                             6.49867      -6.428871   -14678.86
##                          Staphylococcus Aerococcus  Atopostipes Dolosigranulum
## (Intercept)                   1136933.6 139248.898  245.4619464      103939.34
## format_16S_L6_AA$Group11     14971439.7 -91299.915  720.3152172     -204134.68
## format_16S_L6_AA$Group12    -12494240.6 -78024.419 -240.1050724     -603260.79
## format_16S_L6_AA$Group13    -10002668.7 208547.145 -240.1050724     -602358.54
## dph                            621707.5  -1678.231   -0.2819407       26340.08
##                          Granulicatella Trichococcus Enterococcus Lactobacillus
## (Intercept)                  92.0312672    182.17092    731722133    5082559939
## format_16S_L6_AA$Group11    289.9799015    375.61877   -319140914   -6075140788
## format_16S_L6_AA$Group12    -96.6599672   -125.20626   -344995064   -5316636462
## format_16S_L6_AA$Group13    -96.6599672   -125.20626     60987494    7863249137
## dph                           0.2436158     -2.99814    -19698072     200091780
##                          Leuconostoc   Weissella Lactococcus Streptococcus
## (Intercept)               9686.00372  19639.8577    -17.3145    2828928163
## format_16S_L6_AA$Group11 13788.39152  37456.7995  24720.6982   -1616104609
## format_16S_L6_AA$Group12 -7780.38806 -18073.6237  -8188.8886   -1610750888
## format_16S_L6_AA$Group13  1826.62021   3092.8912  -8265.9048    -985862136
## dph                        -97.44106    149.2742    435.9589     -62420044
##                               X__.26 Christensenellaceae.R.7.group uncultured.8
## (Intercept)                177.51227                      33557077    221861.44
## format_16S_L6_AA$Group11  5723.95019                    -276623435   -707706.81
## format_16S_L6_AA$Group12 -1907.98340                    -276305768   -707706.81
## format_16S_L6_AA$Group13 -1907.98340                    -275417499   -707706.81
## dph                         91.07743                      12796410     25570.81
##                              X__.27 Candidatus.Arthromitus
## (Intercept)                84788.37              348201821
## format_16S_L6_AA$Group11 -277850.54             -277227613
## format_16S_L6_AA$Group12 -277850.54             -251651564
## format_16S_L6_AA$Group13 -277850.54              800152362
## dph                        10161.17               -3651318
##                          Clostridium.sensu.stricto.1
## (Intercept)                                327028509
## format_16S_L6_AA$Group11                  -121595493
## format_16S_L6_AA$Group12                  -122227132
## format_16S_L6_AA$Group13                  -121677923
## dph                                        -10776496
##                          Clostridium.sensu.stricto.11 gut.metagenome.1
## (Intercept)                               295.4153440       20040442.2
## format_16S_L6_AA$Group11                  839.0112263      -23310843.9
## format_16S_L6_AA$Group12                 -279.6704088      -23312591.8
## format_16S_L6_AA$Group13                 -279.6704088      -23304014.2
## dph                                        -0.8286808         172492.3
##                          uncultured.Clostridia.bacterium
## (Intercept)                                     28501623
## format_16S_L6_AA$Group11                       -50094705
## format_16S_L6_AA$Group12                       -49768778
## format_16S_L6_AA$Group13                       -49279264
## dph                                              1137325
##                          uncultured.Firmicutes.bacterium
## (Intercept)                                    961521777
## format_16S_L6_AA$Group11                      -566992665
## format_16S_L6_AA$Group12                      -567008819
## format_16S_L6_AA$Group13                      -566301748
## dph                                            -20762810
##                          uncultured.Thermoanaerobacterales.bacterium
## (Intercept)                                                 766692.4
## format_16S_L6_AA$Group11                                  -3931898.9
## format_16S_L6_AA$Group12                                  -3932064.8
## format_16S_L6_AA$Group13                                  -3932228.0
## dph                                                         166607.1
##                          uncultured.bacterium.15 uncultured.organism.1
## (Intercept)                            609523148              -8324092
## format_16S_L6_AA$Group11              -765955774             -61418871
## format_16S_L6_AA$Group12              -765350865             -61248673
## format_16S_L6_AA$Group13              -761592162             -60478510
## dph                                      8240786               3670819
##                          uncultured.prokaryote uncultured.rumen.bacterium.1
## (Intercept)                         -1779693.6                    4205126.9
## format_16S_L6_AA$Group11            -4206000.4                  -12316983.4
## format_16S_L6_AA$Group12            -4196225.9                  -12316610.5
## format_16S_L6_AA$Group13            -4175557.1                  -12316983.4
## dph                                   315036.5                     426939.8
##                               X__.28 Defluviitaleaceae.UCG.011  Anaerofustis
## (Intercept)                9245811.6                12248078.0  12601375.434
## format_16S_L6_AA$Group11 -25768768.6               -14269950.6 -12502859.154
## format_16S_L6_AA$Group12 -25777376.7               -14266303.9 -12503638.889
## format_16S_L6_AA$Group13 -25773273.9               -14218770.7 -12501986.202
## dph                         870087.7                  106476.5     -5112.166
##                          Anaerococcus  Ezakiella Finegoldia Gottschalkia
## (Intercept)                5641836.24  9459351.7  9910963.6    213.24669
## format_16S_L6_AA$Group11  -4332595.04 -5959816.2 -7518592.7    -59.12406
## format_16S_L6_AA$Group12  -4332595.04 -5959816.2 -7518592.7    234.22011
## format_16S_L6_AA$Group13  -4332595.04 -5959816.2 -7518592.7    -87.54802
## dph                         -68907.43  -184186.1  -125914.3     -6.61572
##                          Murdochiella  Parvimonas Peptoniphilus
## (Intercept)                268377.010  513.719560    3343415.36
## format_16S_L6_AA$Group11  -206071.418 2104.200612   -3102219.51
## format_16S_L6_AA$Group12  -206071.418 -701.400204   -3102219.51
## format_16S_L6_AA$Group13  -206071.418 -701.400204   -3102219.51
## dph                         -3279.242    9.877929     -12694.52
##                          Family.XIII.AD3011.group Family.XIII.UCG.001
## (Intercept)                             5124908.4           4982972.5
## format_16S_L6_AA$Group11              -20244877.7          -5652351.9
## format_16S_L6_AA$Group12              -20244000.9          -5650437.9
## format_16S_L6_AA$Group13              -20093462.5          -5488520.4
## dph                                      795788.2             35232.6
##                             S5.A14a X.Eubacterium..brachy.group
## (Intercept)               70421.508                   2312229.4
## format_16S_L6_AA$Group11 -99157.616                  -4747027.8
## format_16S_L6_AA$Group12 -99157.616                  -4747263.2
## format_16S_L6_AA$Group13 -99157.616                  -4747263.2
## dph                        1512.427                    128159.7
##                          X.Eubacterium..nodatum.group     X__.29    ASF356
## (Intercept)                                 9604548.6 -41472.186  83533307
## format_16S_L6_AA$Group11                  -15920316.3 -64361.221 -41160987
## format_16S_L6_AA$Group12                  -15918930.0 -64353.608 -41159286
## format_16S_L6_AA$Group13                  -15843246.2 -64361.221 -41161013
## dph                                          332408.8   5570.179  -2230121
##                          Acetitomaculum Agathobacter Anaerostipes     Blautia
## (Intercept)                  -25740.333    249393.46    323648597  1533019038
## format_16S_L6_AA$Group11     -82617.973   -771619.30   -357223989 -1224005037
## format_16S_L6_AA$Group12     150038.238  -1926515.37   -355362807 -1224049391
## format_16S_L6_AA$Group13      30627.383  -1918553.71   -342987328 -1186267878
## dph                            6515.157     88529.32      1772817   -15990539
##                          Butyrivibrio    CAG.56   CHKCI001 Coprococcus.2
## (Intercept)                  25777.04  40144136  132204206    698.213503
## format_16S_L6_AA$Group11   -683595.31 -27518205 -169606367   1907.969845
## format_16S_L6_AA$Group12   -683595.31 -27519623 -168811562   -635.989948
## format_16S_L6_AA$Group13   -683595.31 -27522587 -166686548   -635.989948
## dph                          34622.01   -664292    1986331     -3.274924
##                          Coprococcus.3     Dorea Eisenbergiella Epulopiscium
## (Intercept)                  -35019.98  1290.181      673078960     82360.75
## format_16S_L6_AA$Group11      86858.08 26210.099     -370641499    -38320.41
## format_16S_L6_AA$Group12    -190143.12 -8736.700     -370628995    -38331.30
## format_16S_L6_AA$Group13    -190143.12 -8736.700     -369941037    -38331.30
## dph                           11850.69   391.922      -15915189     -2317.34
##                          Fusicatenibacter GCA.900066575 Lachnoclostridium
## (Intercept)                     781720.04     237968252         502562178
## format_16S_L6_AA$Group11       -350322.16    -153642282        -349942941
## format_16S_L6_AA$Group12      -1105520.91    -153629920        -350479619
## format_16S_L6_AA$Group13      -1015439.41    -153492154        -348756240
## dph                              18199.09      -4438063          -7993993
##                          Lachnospira Lachnospiraceae.FCS020.group
## (Intercept)               4205495.86                    9693584.8
## format_16S_L6_AA$Group11 -3356837.62                  -11856567.5
## format_16S_L6_AA$Group12 -4692831.23                  -11855395.3
## format_16S_L6_AA$Group13 -4562038.49                  -11856699.7
## dph                         26814.08                     113848.2
##                          Lachnospiraceae.ND3007.group
## (Intercept)                                13993.6054
## format_16S_L6_AA$Group11                   29300.1282
## format_16S_L6_AA$Group12                   -9766.7094
## format_16S_L6_AA$Group13                   -9766.7094
## dph                                         -222.4682
##                          Lachnospiraceae.NK4A136.group Lachnospiraceae.UCG.003
## (Intercept)                                  101288646               55917.537
## format_16S_L6_AA$Group11                     -59921806               58395.157
## format_16S_L6_AA$Group12                     -60195736              -20535.858
## format_16S_L6_AA$Group13                     -59588366              -17323.442
## dph                                           -2162597               -1862.194
##                          Lachnospiraceae.UCG.004 Lachnospiraceae.UCG.010
## (Intercept)                             2052.712               9976997.8
## format_16S_L6_AA$Group11               -2008.253              -7086026.2
## format_16S_L6_AA$Group12              -51958.881              -7086014.5
## format_16S_L6_AA$Group13              -51958.881              -7086026.2
## dph                                     2626.640               -152156.4
##                          Marvinbryantia   Roseburia Sellimonas Shuttleworthia
## (Intercept)                 134322210.2  4269016.04  775408882    201905373.7
## format_16S_L6_AA$Group11   -118894843.1 -3226970.93 -512185043   -193236098.6
## format_16S_L6_AA$Group12   -118906114.5 -3677599.90 -511088543   -193220044.5
## format_16S_L6_AA$Group13   -118470462.4 -3562841.17 -506087446   -192388399.7
## dph                           -810883.3   -30239.85  -13842824      -455061.8
##                          Tyzzerella Tyzzerella.3 Tyzzerella.4   UC5.1.2E3
## (Intercept)               308826186     25378957  102633.4824   8213268.0
## format_16S_L6_AA$Group11 -261503588    -12680723  -84733.3700 -13423975.0
## format_16S_L6_AA$Group12 -260846807    -12708958  -85748.1849 -13429199.4
## format_16S_L6_AA$Group13 -247119694    -12703706  -85748.1849 -13429199.4
## dph                        -2486547      -666842    -888.6999    274522.7
##                          X.Eubacterium..eligens.group
## (Intercept)                                  8860.563
## format_16S_L6_AA$Group11                   148839.192
## format_16S_L6_AA$Group12                   -67575.144
## format_16S_L6_AA$Group13                   -67575.144
## dph                                          3090.241
##                          X.Eubacterium..hallii.group
## (Intercept)                              371196340.8
## format_16S_L6_AA$Group11                -380962423.3
## format_16S_L6_AA$Group12                -379595983.5
## format_16S_L6_AA$Group13                -362493589.1
## dph                                         555542.4
##                          X.Eubacterium..ventriosum.group
## (Intercept)                                   8304796.54
## format_16S_L6_AA$Group11                     -6517310.06
## format_16S_L6_AA$Group12                     -6520404.42
## format_16S_L6_AA$Group13                     -6520404.42
## dph                                            -93915.37
##                          X.Ruminococcus..gauvreauii.group
## (Intercept)                                     214316415
## format_16S_L6_AA$Group11                       -137555272
## format_16S_L6_AA$Group12                       -137353768
## format_16S_L6_AA$Group13                       -134072153
## dph                                              -4037935
##                          X.Ruminococcus..gnavus.group
## (Intercept)                                 2194416.8
## format_16S_L6_AA$Group11                   -1198040.8
## format_16S_L6_AA$Group12                   -3906077.0
## format_16S_L6_AA$Group13                   -3830547.1
## dph                                           90143.8
##                          X.Ruminococcus..torques.group uncultured.9      X__.30
## (Intercept)                                 6024884859   53802223.6  3617594938
## format_16S_L6_AA$Group11                   -3705181371  -70549444.4 -2959000668
## format_16S_L6_AA$Group12                   -3698553894  -70560761.9 -2949915570
## format_16S_L6_AA$Group13                   -3632430217  -70531175.7 -2899598711
## dph                                         -122011900     882575.1   -34527297
##                          Peptococcus uncultured.10 Clostridioides
## (Intercept)                302502.65     8804978.2      576572.20
## format_16S_L6_AA$Group11  -918105.89   -20351433.0     -277997.30
## format_16S_L6_AA$Group12  -918105.89   -20351064.3     -278333.45
## format_16S_L6_AA$Group13  -918105.89   -20253066.1     -278333.45
## dph                         32400.17      607862.5      -15696.78
##                          Intestinibacter Peptostreptococcus Romboutsia
## (Intercept)                   -28059.721          76118.234  186150033
## format_16S_L6_AA$Group11      -18696.955        -108116.040 -380239944
## format_16S_L6_AA$Group12      -74565.381        -108116.040 -378705137
## format_16S_L6_AA$Group13      -74660.419        -108116.040  450835306
## dph                             5406.323           1684.095   10341822
##                             X__.31 Anaerofilum Anaerotruncus Angelakisella
## (Intercept)              113202311   386538824     137608072    9170587.44
## format_16S_L6_AA$Group11 -80181651  -216941444    -102293854   -8755502.67
## format_16S_L6_AA$Group12 -56590000  -216929603    -102304324   -8755231.43
## format_16S_L6_AA$Group13 152051984  -216731665    -101985360   -8755502.67
## dph                       -1585800    -8924636      -1857866     -21846.57
##                          Butyricicoccus    CAG.352 Candidatus.Soleaferrea
## (Intercept)                  1848476058  1245178.9             15007118.8
## format_16S_L6_AA$Group11    -1120709143 -1550372.1            -19757257.6
## format_16S_L6_AA$Group12    -1120269410 -1550290.8            -19756688.7
## format_16S_L6_AA$Group13    -1117634294 -1550372.1            -19755663.3
## dph                           -38286077    16062.8               250040.9
##                          Caproiciproducens    DTU089 Faecalibacterium
## (Intercept)                       73615550 127725547        220204611
## format_16S_L6_AA$Group11         -37607012 -91017666      -2948403496
## format_16S_L6_AA$Group12         -37607120 -91043262      -2945960837
## format_16S_L6_AA$Group13         -37607242 -90930682      -2857076245
## dph                               -1895174  -1930273        144395176
##                          Flavonifractor Fournierella GCA.900066225 Harryflintia
## (Intercept)                   461224657    283696025     145559433    1527837.4
## format_16S_L6_AA$Group11     -318255737   -359601849     -96462977   -1824419.9
## format_16S_L6_AA$Group12     -318822512   -359107534     -96475926   -1824419.9
## format_16S_L6_AA$Group13     -318113292   -355525001     -96408956   -1824419.9
## dph                            -7492710      3999042      -2583239      15609.6
##                          Hydrogenoanaerobacterium Intestinimonas
## (Intercept)                           7541061.280      437582060
## format_16S_L6_AA$Group11             -7588225.133     -341714410
## format_16S_L6_AA$Group12             -7589303.637     -341748810
## format_16S_L6_AA$Group13             -7584557.684     -341475552
## dph                                      2539.071       -5042874
##                          Negativibacillus Oscillibacter Oscillospira
## (Intercept)                     599076204     267164975   14646105.8
## format_16S_L6_AA$Group11       -389693078    -154831067  -21246246.6
## format_16S_L6_AA$Group12       -389383776    -154839777  -21247430.6
## format_16S_L6_AA$Group13       -386701763    -154543541  -21225628.6
## dph                             -11015995      -5910775     347441.8
##                          Papillibacter      Phocea Pseudoflavonifractor
## (Intercept)                  -9540.581   209801.56            137854050
## format_16S_L6_AA$Group11   -244911.749 -1734841.19            -63581710
## format_16S_L6_AA$Group12   -244911.749 -1734841.19            -63581710
## format_16S_L6_AA$Group13   -244911.749 -1734841.19            -63581710
## dph                          13392.228    80265.24             -3909071
##                          Ruminiclostridium Ruminiclostridium.1
## (Intercept)                      172152643            973554.6
## format_16S_L6_AA$Group11        -141148104          -4612783.6
## format_16S_L6_AA$Group12        -140798148          -4611773.5
## format_16S_L6_AA$Group13        -139532260          -4610998.0
## dph                               -1631145            191538.4
##                          Ruminiclostridium.5 Ruminiclostridium.6
## (Intercept)                        375570738           1081.6517
## format_16S_L6_AA$Group11          -267811204          11942.2922
## format_16S_L6_AA$Group12          -267749068          -3980.7641
## format_16S_L6_AA$Group13          -266673610          -3980.7641
## dph                                 -5669722            152.5849
##                          Ruminiclostridium.9 Ruminococcaceae.NK4A214.group
## (Intercept)                        631085486                       6241201
## format_16S_L6_AA$Group11          -410185024                     -78765706
## format_16S_L6_AA$Group12          -409586737                     -79096921
## format_16S_L6_AA$Group13          -407633066                     -78783733
## dph                                -11623518                       3844479
##                          Ruminococcaceae.UCG.002 Ruminococcaceae.UCG.003
## (Intercept)                            -94837.99              14188.6144
## format_16S_L6_AA$Group11               340868.52              75106.2453
## format_16S_L6_AA$Group12              -254389.33             -24266.9644
## format_16S_L6_AA$Group13              -254906.87             -25419.6405
## dph                                     18407.62                591.1066
##                          Ruminococcaceae.UCG.004 Ruminococcaceae.UCG.005
## (Intercept)                             45595948               269224063
## format_16S_L6_AA$Group11               -66914910              -623689290
## format_16S_L6_AA$Group12               -66827630              -622598350
## format_16S_L6_AA$Group13               -65478640              -619962149
## dph                                      1122354                18659443
##                          Ruminococcaceae.UCG.008 Ruminococcaceae.UCG.009
## (Intercept)                            -354137.0              27510437.4
## format_16S_L6_AA$Group11              -1602959.0             -29658257.5
## format_16S_L6_AA$Group12              -1602959.0             -29657565.9
## format_16S_L6_AA$Group13              -1599664.4             -29659665.0
## dph                                     103005.1                113214.6
##                          Ruminococcaceae.UCG.010 Ruminococcaceae.UCG.013
## (Intercept)                             18797585             142871656.2
## format_16S_L6_AA$Group11               -56233782            -124611909.7
## format_16S_L6_AA$Group12               -56228128            -124646895.9
## format_16S_L6_AA$Group13               -56142994            -124154013.9
## dph                                      1970399               -957776.9
##                          Ruminococcaceae.UCG.014 Ruminococcaceae.V9D2013.group
## (Intercept)                            352091433                      6839.272
## format_16S_L6_AA$Group11              -733667114                    -51668.849
## format_16S_L6_AA$Group12              -732651057                    -51668.849
## format_16S_L6_AA$Group13              -730138181                    -51668.849
## dph                                     20084722                      2359.451
##                          Ruminococcus.1 Ruminococcus.2 Subdoligranulum
## (Intercept)                  10073092.0      2664545.3       162435976
## format_16S_L6_AA$Group11    -26542480.2    -10209189.0      -293572532
## format_16S_L6_AA$Group12    -27186979.1    -10922594.6      -293822769
## format_16S_L6_AA$Group13    -27004401.6    -10837299.3      -288930188
## dph                            901575.6       434968.8         6966487
##                              UBA1819 X.Eubacterium..coprostanoligenes.group
## (Intercept)               3309757.58                              246295395
## format_16S_L6_AA$Group11 -2150783.65                             -277255526
## format_16S_L6_AA$Group12 -2152893.78                             -278126717
## format_16S_L6_AA$Group13 -2152893.78                             -277802713
## dph                        -60887.57                                1677137
##                          uncultured.11     X__.32 Syntrophomonas      X__.33
## (Intercept)                  537490166 1004519005      282.12249    76117.33
## format_16S_L6_AA$Group11    -430622591 -574226716     5128.49907 -4101495.82
## format_16S_L6_AA$Group12    -430608445 -574286170    -1709.49969 -4101319.35
## format_16S_L6_AA$Group13    -429477632 -573921784    -1709.49969 -4090103.80
## dph                           -5622252  -22642591       75.12512   211876.74
##                          uncultured.bacterium.16 Allobaculum Asteroleplasma
## (Intercept)                            1934602.1   -47676.76     317.235873
## format_16S_L6_AA$Group11              -7321668.7   340189.90     653.105360
## format_16S_L6_AA$Group12              -7319539.5  -231978.18    -217.701787
## format_16S_L6_AA$Group13              -7286653.7   131650.94    -217.701787
## dph                                     283529.8    15133.65      -5.238636
##                          Dubosiella Erysipelatoclostridium Erysipelothrix
## (Intercept)              113608.445             2481882322      49.640366
## format_16S_L6_AA$Group11 -32409.630            -1406031816     297.259992
## format_16S_L6_AA$Group12 -49286.900            -1405800150     -99.086664
## format_16S_L6_AA$Group13 -46835.464            -1403289777     -99.086664
## dph                       -3360.807              -56607287       2.602437
##                          Erysipelotrichaceae.UCG.003 Holdemanella  Holdemania
## (Intercept)                               1756360.36    4755.9750  7972032.32
## format_16S_L6_AA$Group11                 -1538096.35   13346.7686 -7638537.83
## format_16S_L6_AA$Group12                 -2009491.99   -5676.1926 -7638531.97
## format_16S_L6_AA$Group13                 -1886866.98   -1994.3834 -7638537.83
## dph                                         14176.03      48.4325   -17552.34
##                          Ileibacterium Merdibacter Turicibacter
## (Intercept)                 18624.7103  16746013.2    73814.699
## format_16S_L6_AA$Group11    20522.9790 -19848456.3  -132721.266
## format_16S_L6_AA$Group12    -6837.0886 -19835514.8  -131949.081
## format_16S_L6_AA$Group13    -6842.9452 -19791269.6   400318.708
## dph                          -620.0929    163314.3     3254.403
##                          X.Clostridium..innocuum.group uncultured.12
## (Intercept)                                 19250732.3   171461080.3
## format_16S_L6_AA$Group11                    -9047319.3  -167357128.7
## format_16S_L6_AA$Group12                    -9054574.3  -167356107.4
## format_16S_L6_AA$Group13                    -9033481.2  -167029199.5
## dph                                          -536639.9     -214424.9
##                          uncultured.bacterium.17     X__.34
## (Intercept)                             23103504 -5346.6866
## format_16S_L6_AA$Group11               -42769543 -7709.5726
## format_16S_L6_AA$Group12               -42767497 -7709.5726
## format_16S_L6_AA$Group13               -42715161 -7709.5726
## dph                                      1035059   687.1715
##                          Phascolarctobacterium  Dialister  Megamonas
## (Intercept)                           57466544  -87471.16 -130124316
## format_16S_L6_AA$Group11            -293395728   75153.79 -139712079
## format_16S_L6_AA$Group12            -293900651 -150235.88 -140694028
## format_16S_L6_AA$Group13            -290488296 -138305.16 -140485684
## dph                                   12487501   12702.03   14254323
##                          Megasphaera   Quinella Veillonella      X__.35
## (Intercept)               -86188.930   163.9290  425488.711  258152.967
## format_16S_L6_AA$Group11  199814.047  8639.1769 -194298.662 -131438.717
## format_16S_L6_AA$Group12  -78156.262 -2879.7256 -283821.460 -114663.597
## format_16S_L6_AA$Group13  -78156.262 -2879.7256 -283821.460 -108197.372
## dph                         8649.747   142.9367   -7456.171   -6669.171
##                          Fusobacterium   Sneathia uncultured.bacterium.18
## (Intercept)                 -2383320.5 1766403.86              796.698069
## format_16S_L6_AA$Group11     6416946.0 -900157.24             2830.605479
## format_16S_L6_AA$Group12    -2363102.1 -900157.24             -943.535160
## format_16S_L6_AA$Group13    -2329869.0 -900157.24             -943.535160
## dph                           250059.1  -45591.93                7.728268
##                           Gemmatimonas uncultured.13     X__.36
## (Intercept)               6149.7846521    -594925.88  1325.4816
## format_16S_L6_AA$Group11 17771.1667554    1629331.85 19278.0002
## format_16S_L6_AA$Group12 -5454.5280524    -543057.13 -6426.0001
## format_16S_L6_AA$Group13 -6158.3193515    -543137.36 -6426.0001
## dph                          0.4491947      59898.07   268.4483
##                          uncultured.bacterium.19 uncultured.bacterium.20
## (Intercept)                            5743.4411              -941486.06
## format_16S_L6_AA$Group11              25566.1539              2353020.88
## format_16S_L6_AA$Group12              -8354.2347              -784340.29
## format_16S_L6_AA$Group13              -8605.9596              -784340.29
## dph                                     150.6589                90832.97
##                          Victivallis uncultured.bacterium.21  Nitrospira
## (Intercept)                 85236.41              -415.16408   9166.6273
## format_16S_L6_AA$Group11  -882521.25              1300.84787  46054.6057
## format_16S_L6_AA$Group12  -882209.86              -433.61596 -15351.5352
## format_16S_L6_AA$Group13  -882521.25              -433.61596 -15351.5352
## dph                         41962.36                44.67263    325.5215
##                          uncultured.bacterium.22 uncultured.prokaryote.1
## (Intercept)                           -166580.37               9468.8848
## format_16S_L6_AA$Group11              1294586.92              29929.0387
## format_16S_L6_AA$Group12              -431053.45              -9976.3462
## format_16S_L6_AA$Group13              -431766.74              -9976.3462
## dph                                     31491.95                 26.7085
##                               X__.37 uncultured.bacterium.23     X__.38
## (Intercept)               4968.32834               247.48909  842.88146
## format_16S_L6_AA$Group11 14222.23165              3946.58776 1038.13011
## format_16S_L6_AA$Group12 -4740.74388             -1315.52925 -346.04337
## format_16S_L6_AA$Group13 -4740.74388             -1315.52925 -346.04337
## dph                        -11.97813                56.21264  -26.14937
##                          uncultured.bacterium.24 uncultured.bacterium.25
## (Intercept)                           2352.02469               225.23308
## format_16S_L6_AA$Group11             12057.58817              3472.65397
## format_16S_L6_AA$Group12             -4019.19606             -1157.55132
## format_16S_L6_AA$Group13             -4019.19606             -1157.55132
## dph                                     87.74586                49.06938
##                          Candidatus.Saccharimonas uncultured.bacterium.26
## (Intercept)                            2659.81040              1204.18147
## format_16S_L6_AA$Group11              10078.17034              7190.42782
## format_16S_L6_AA$Group12              -3359.39011             -2396.80927
## format_16S_L6_AA$Group13              -3359.39011             -2396.80927
## dph                                      36.81999                62.76988
##                               X__.39 Candidatus.Brocadia    X__.40
## (Intercept)               -474.31209          272.673205  802.7949
## format_16S_L6_AA$Group11  3855.11319          955.681657 2827.6424
## format_16S_L6_AA$Group12 -1285.03773         -318.560552 -942.5475
## format_16S_L6_AA$Group13 -1285.03773         -318.560552 -942.5475
## dph                         92.59736            2.415124    7.3554
##                          Planctomycetes.bacterium.RIFCSPHIGHO2_02_FULL_50_42
## (Intercept)                                                        3976.2865
## format_16S_L6_AA$Group11                                          24542.9112
## format_16S_L6_AA$Group12                                          -8180.9704
## format_16S_L6_AA$Group13                                          -8180.9704
## dph                                                                 221.2992
##                          uncultured.14 uncultured.bacterium.27
## (Intercept)                  1039.1723               3309.5363
## format_16S_L6_AA$Group11    12983.3549              17511.5618
## format_16S_L6_AA$Group12    -4327.7850              -5837.1873
## format_16S_L6_AA$Group13    -4327.7850              -5837.1873
## dph                           173.0849                133.0343
##                          uncultured.planctomycete uncultured.bacterium.28
## (Intercept)                             1102.3487              290.744915
## format_16S_L6_AA$Group11               15287.1804              323.437276
## format_16S_L6_AA$Group12               -5095.7268              -61.507281
## format_16S_L6_AA$Group13               -5095.7268             -130.964997
## dph                                      210.1778               -8.409469
##                          Fimbriiglobus uncultured.15 Singulisphaera
## (Intercept)                 -297.15042     3751.0111      -390.5296
## format_16S_L6_AA$Group11    1677.28036     9517.3493      1765.8548
## format_16S_L6_AA$Group12    -559.09345    -3172.4498      -588.6183
## format_16S_L6_AA$Group13    -559.09345    -3172.4498      -588.6183
## dph                           45.06547      -30.4506        51.5341
##                          Pir4.lineage uncultured.16
## (Intercept)                 555.71362      69.03094
## format_16S_L6_AA$Group11   1602.76050    2014.60209
## format_16S_L6_AA$Group12   -534.25350    -461.81671
## format_16S_L6_AA$Group13   -534.25350    -776.39269
## dph                          -1.12948      37.22957
##                          uncultured.Crater.Lake.bacterium.CL500.4      X__.41
## (Intercept)                                            -230.12159  1609.33623
## format_16S_L6_AA$Group11                                778.98436  3735.96815
## format_16S_L6_AA$Group12                               -259.66145 -1245.32272
## format_16S_L6_AA$Group13                               -259.66145 -1245.32272
## dph                                                      25.77805   -19.15861
##                          uncultured.17 Azospirillum Skermanella Inquilinus
## (Intercept)                  502.74906   2560.92653  -591952.12  -85667.07
## format_16S_L6_AA$Group11    4822.28722  11142.94087  1508799.45  670242.51
## format_16S_L6_AA$Group12   -1338.94296  -3714.31362  -505960.80 -223182.70
## format_16S_L6_AA$Group13   -1741.67213  -3714.31362  -496877.84 -223529.90
## dph                           65.20648     60.70458    57784.89   16273.53
##                          uncultured.bacterium.29 Brevundimonas Caulobacter
## (Intercept)                           -256998.59    4975.90512   469.40113
## format_16S_L6_AA$Group11               672435.82    8410.61260  2984.53327
## format_16S_L6_AA$Group12              -224145.27   -1279.34829  -994.84442
## format_16S_L6_AA$Group13              -224145.27   -3565.63216  -994.84442
## dph                                     25323.36     -74.22489    27.65491
##                          Phenylobacterium uncultured.18     X__.42        SWB02
## (Intercept)                   9050.782569    290.832766  2075.8132  1032.266925
## format_16S_L6_AA$Group11     27305.126214    791.646356 13229.6758  3004.751863
## format_16S_L6_AA$Group12     -9101.708738   -263.882119 -4409.8919 -1001.583954
## format_16S_L6_AA$Group13     -9101.708738   -263.882119 -4409.8919 -1001.583954
## dph                              2.680325     -1.418455   122.8463    -1.614893
##                              Dongia Reyranella uncultured.bacterium.30
## (Intercept)                994.1096  2942.9948               409.86268
## format_16S_L6_AA$Group11 14605.9042 18500.8112              3360.93503
## format_16S_L6_AA$Group12 -4868.6347 -6166.9371             -1120.31168
## format_16S_L6_AA$Group13 -4868.6347 -6166.9371             -1120.31168
## dph                        203.9224   169.6812                37.39205
##                              Bosea Methylobacterium  Microvirga    Devosia
## (Intercept)               3036.833        5178.3788  2866.16149 -3092.1234
## format_16S_L6_AA$Group11 23928.104       26850.3743  4993.19289  7869.5220
## format_16S_L6_AA$Group12 -7976.035       -8901.1696 -1437.00782 -2233.3629
## format_16S_L6_AA$Group13 -7976.035       -8974.6024 -1778.09253 -2818.0795
## dph                        259.958         199.8012   -57.26679   311.0633
##                               X__.43 uncultured.19 uncultured.20
## (Intercept)                409.88716    247.582777     5857.9205
## format_16S_L6_AA$Group11  6751.04306   1074.691416     7393.1718
## format_16S_L6_AA$Group12 -2250.34769   -358.230472    -2464.3906
## format_16S_L6_AA$Group13 -2250.34769   -358.230472    -2464.3906
## dph                         96.86634      5.823563     -178.6068
##                          Allorhizobium.Neorhizobium.Pararhizobium.Rhizobium
## (Intercept)                                                        1514.004
## format_16S_L6_AA$Group11                                          68284.633
## format_16S_L6_AA$Group12                                         -22761.544
## format_16S_L6_AA$Group13                                         -22761.544
## dph                                                                1118.292
##                             Ensifer Mesorhizobium Phyllobacterium     X__.44
## (Intercept)              -1138.2295      890.9351       13472.361  155312.01
## format_16S_L6_AA$Group11  5573.6024    21116.3873      151861.690 -103650.83
## format_16S_L6_AA$Group12 -1857.8675    -7038.7958      -51825.747 -104847.07
## format_16S_L6_AA$Group13 -1857.8675    -7038.7958      -48121.494 -104847.07
## dph                        157.6893      323.5716        2023.268   -2656.05
##                             Bauldia Bradyrhizobium Pseudolabrys
## (Intercept)               5729.1602     -182573.00   3444.74756
## format_16S_L6_AA$Group11  7056.2873      532367.47   5335.15197
## format_16S_L6_AA$Group12 -2352.0958     -179936.18  -1096.41816
## format_16S_L6_AA$Group13 -2352.0958     -172139.71  -2119.36690
## dph                       -177.7402       19098.14    -69.75688
##                          Rhodopseudomonas   Starkeya uncultured.21
## (Intercept)                      2470.526   479.7668    3764.79080
## format_16S_L6_AA$Group11       188579.890  3215.7968   14096.68488
## format_16S_L6_AA$Group12       -62859.963 -1071.9323   -4698.89496
## format_16S_L6_AA$Group13       -62859.963 -1071.9323   -4698.89496
## dph                              3178.391    31.1666      49.16338
##                          uncultured.bacterium.31     X__.45 Gemmobacter
## (Intercept)                           1673.37848  10453.714  353.531109
## format_16S_L6_AA$Group11              6540.70439 -55587.738 1305.894803
## format_16S_L6_AA$Group12             -2180.23480 -58775.259 -435.298268
## format_16S_L6_AA$Group13             -2180.23480 -58775.259 -435.298268
## dph                                     26.67665   2543.239    4.303535
##                          Rhodobacter Rubellimicrobium     X__.46
## (Intercept)               -68.595052       166646.834   61.01161
## format_16S_L6_AA$Group11  267.715883       -58654.181 2838.04757
## format_16S_L6_AA$Group12  -89.238628      -124288.286 -946.01586
## format_16S_L6_AA$Group13  -89.238628      -124288.286 -946.01586
## dph                         8.307036        -2229.397   46.57917
##                          Azospirillum.sp..47_25 gut.metagenome.2
## (Intercept)                          30355357.7          6293431
## format_16S_L6_AA$Group11            -40948167.6        -31686691
## format_16S_L6_AA$Group12            -40967776.0        -31646297
## format_16S_L6_AA$Group13            -40857958.1        -31355891
## dph                                    558720.8          1337590
##                          unidentified.rumen.bacterium.RF32
## (Intercept)                                       20288632
## format_16S_L6_AA$Group11                         -40237952
## format_16S_L6_AA$Group12                         -40230763
## format_16S_L6_AA$Group13                         -40130634
## dph                                                1050152
##                          uncultured.bacterium.32 Novosphingobium Sphingobium
## (Intercept)                           386307.149      -1740.9417   -429911.5
## format_16S_L6_AA$Group11             -296802.066      -1322.5367   2664983.5
## format_16S_L6_AA$Group12             -288256.967      -1469.4401   -893751.0
## format_16S_L6_AA$Group13              882263.071       4261.4169   -876866.7
## dph                                    -4689.637        168.9675     69698.8
##                          Sphingomonas Sphingopyxis uncultured.22      X__.47
## (Intercept)                 6957.2858    510.70529    3792.57526  994.970708
## format_16S_L6_AA$Group11     480.6251   1036.20102    7811.80882 2524.642049
## format_16S_L6_AA$Group12   -3880.4039   -345.40034   -2603.93627 -841.547350
## format_16S_L6_AA$Group13    7280.1826   -345.40034   -2603.93627 -841.547350
## dph                         -161.9412     -8.70026     -62.55995   -8.074914
##                          Candidatus.Alysiosphaera uncultured.23
## (Intercept)                            -17544.003      16.08310
## format_16S_L6_AA$Group11               -33009.333    1281.12457
## format_16S_L6_AA$Group12               -33009.333    -327.60959
## format_16S_L6_AA$Group13               -33009.333    -476.75749
## dph                                      2660.702      24.24602
##                          uncultured.bacterium.33     X__.48 Peredibacter
## (Intercept)                            2140.6319 1111.82662  1081.191111
## format_16S_L6_AA$Group11              28480.1052 1734.06085  3371.397144
## format_16S_L6_AA$Group12              -9493.3684 -384.57588 -1123.799048
## format_16S_L6_AA$Group13              -9493.3684 -674.74248 -1123.799048
## dph                                     386.9861  -23.00443     2.242523
##                          Bdellovibrio uncultured.24  Bilophila Desulfovibrio
## (Intercept)               13003.67555      60.75521   74606134    -58270.119
## format_16S_L6_AA$Group11  34430.94820    1846.51934 -174389140    176136.623
## format_16S_L6_AA$Group12 -11476.98273    -615.50645 -173757828    -58712.208
## format_16S_L6_AA$Group13 -11476.98273    -615.50645 -165508748    -58712.208
## dph                         -80.35225      29.19743    5256794      6156.965
##                          uncultured.25     X__.49 uncultured.bacterium.34
## (Intercept)                  9635786.5  -532946.3               -409.0778
## format_16S_L6_AA$Group11   -22256476.0 -3354203.0               4620.9371
## format_16S_L6_AA$Group12   -23349780.1 -3346838.4              -1540.3124
## format_16S_L6_AA$Group13   -22932003.9 -3327877.1              -1540.3124
## dph                           726201.9   204586.8                102.5995
##                          Cystobacter     X__.50 uncultured.soil.bacterium
## (Intercept)                862.82459  638.34901                -192.98114
## format_16S_L6_AA$Group11  1504.65391  939.65891                 481.84600
## format_16S_L6_AA$Group12  -501.55130 -313.21964                -160.61533
## format_16S_L6_AA$Group13  -501.55130 -313.21964                -160.61533
## dph                        -19.01438  -17.11207                  18.61034
##                           Haliangium uncultured.delta.proteobacterium
## (Intercept)                153.28846                        372.72706
## format_16S_L6_AA$Group11  4268.65754                       5553.93474
## format_16S_L6_AA$Group12 -1422.88585                      -1851.31158
## format_16S_L6_AA$Group13 -1422.88585                      -1851.31158
## dph                         66.82092                         77.82024
##                          uncultured.26 Deltaproteobacteria.bacterium.GWD2_55_8
## (Intercept)                 117.595346                             3359.345823
## format_16S_L6_AA$Group11    286.508065                            10530.036511
## format_16S_L6_AA$Group12    -95.502688                            -3510.012170
## format_16S_L6_AA$Group13    -95.502688                            -3510.012170
## dph                          -1.162771                                7.929808
##                          uncultured.Myxococcales.bacterium
## (Intercept)                                     -144418.69
## format_16S_L6_AA$Group11                         362866.17
## format_16S_L6_AA$Group12                        -120955.39
## format_16S_L6_AA$Group13                        -120955.39
## dph                                               13967.06
##                          uncultured.bacterium.35 uncultured.soil.bacterium.1
## (Intercept)                           3275.66168                   -253068.2
## format_16S_L6_AA$Group11              5637.32646                    635249.2
## format_16S_L6_AA$Group12             -1879.10882                   -211749.7
## format_16S_L6_AA$Group13             -1879.10882                   -211749.7
## dph                                    -73.50278                     24464.1
##                               X__.51 uncultured.bacterium.36      X__.52
## (Intercept)               649.740228               910.87428  3954.71064
## format_16S_L6_AA$Group11 2085.650039              1440.73550 15277.05888
## format_16S_L6_AA$Group12 -695.216680              -480.24517 -5092.35296
## format_16S_L6_AA$Group13 -695.216680              -480.24517 -5092.35296
## dph                         2.393497               -22.66469    59.87591
##                             RCP1.48 uncultured.27 Marinobacter
## (Intercept)              -45.873706     2759.0076   -2545.5986
## format_16S_L6_AA$Group11 -50.045414    15227.6689   10355.1657
## format_16S_L6_AA$Group12 150.136242    -5075.8896   -3451.7219
## format_16S_L6_AA$Group13 -50.045414    -5075.8896   -3451.7219
## dph                        5.048375      121.9412     315.6484
##                          uncultured.Rhodocyclaceae.bacterium  Acidovorax
## (Intercept)                                       129.705768  2259.24631
## format_16S_L6_AA$Group11                          674.655253  7827.92666
## format_16S_L6_AA$Group12                         -224.885084 -2609.30889
## format_16S_L6_AA$Group13                         -224.885084 -2609.30889
## dph                                                 5.009438    18.42435
##                            Comamonas Cupriavidus Curvibacter    Delftia
## (Intercept)               3071.75145   10097.039   40351.874  40534.889
## format_16S_L6_AA$Group11 -1092.40321  133076.612  646645.251 -16641.521
## format_16S_L6_AA$Group12  4076.28015  -44358.871 -316305.013  49924.563
## format_16S_L6_AA$Group13 -1491.93847  -44358.871    9628.073 -16641.521
## dph                        -83.14805    1803.254   21998.732  -1257.546
##                           Lautropia Limnobacter   Massilia Parasutterella
## (Intercept)              111127.268  -44.836532  7044.5175     1379637.86
## format_16S_L6_AA$Group11 -55662.889  253.082034 12378.4937      341606.40
## format_16S_L6_AA$Group12 -55662.889  -84.360678 -4126.1646    -1781117.50
## format_16S_L6_AA$Group13 -55662.889  -84.360678 -4126.1646    -1731641.16
## dph                       -2919.178    6.799853  -153.5975       21720.34
##                           Pelomonas Polaromonas Polynucleobacter  Ralstonia
## (Intercept)               251.94683   1037.1608       206815.018  1024.7439
## format_16S_L6_AA$Group11 1527.48550  15208.5632      -139428.453  8456.8576
## format_16S_L6_AA$Group12 -509.16183  -5069.5211      -139428.453 -3091.3337
## format_16S_L6_AA$Group13 -509.16183  -5069.5211       418285.360 -2245.1133
## dph                        13.53763    212.2295        -3546.661   110.2982
##                          Sphaerotilus Sutterella Undibacterium Variovorax
## (Intercept)                1153.36178 -110843.22     7886.5668 -194800.53
## format_16S_L6_AA$Group11   1762.39573   59136.16    51613.6942 1281229.89
## format_16S_L6_AA$Group12   -587.46524 -187192.72   -17204.5647 -426978.56
## format_16S_L6_AA$Group13   -587.46524 -183495.24   -17204.5647 -427125.66
## dph                         -29.78403   16163.69      490.4209   32732.96
##                              X__.53  Vogesella Gallionella      X__.54
## (Intercept)              102276.920 13025.7335  -38311.720  1408.23970
## format_16S_L6_AA$Group11 -24054.801 -2079.6369  224940.418  2077.86396
## format_16S_L6_AA$Group12 -57170.864 -3281.4748  -73886.434    68.21733
## format_16S_L6_AA$Group13 140445.338 12671.1737  -75526.992 -1073.04065
## dph                       -2266.171  -300.8248    5991.511   -17.64206
##                          uncultured.28        MM2 Methylobacillus Methylophilus
## (Intercept)                 431.160003 -162193.32      3742.64361      92.44546
## format_16S_L6_AA$Group11   1257.815908  408254.61     13433.90269     187.56822
## format_16S_L6_AA$Group12   -419.271969 -136084.87     -4477.96756     -62.52274
## format_16S_L6_AA$Group13   -419.271969 -136084.87     -4477.96756     -62.52274
## dph                          -0.625686   15698.85        38.70126      -1.57488
##                          Methylotenera  Neisseria uncultured.29       MND1
## (Intercept)                  38168.028  69706.118     106.92435 -235441.09
## format_16S_L6_AA$Group11    -15520.550 -32442.355    2315.39826  588207.55
## format_16S_L6_AA$Group12    -29003.695 -32442.355    -771.79942 -196069.18
## format_16S_L6_AA$Group13    -29111.527 -32442.355    -771.79942 -196069.18
## dph                           -476.658  -1961.251      34.99342   22711.07
##                          Methyloversatilis Sulfuritalea uncultured.30
## (Intercept)                     278.784843   5655.85488    743.554955
## format_16S_L6_AA$Group11        416.890089   5345.07215   1873.075906
## format_16S_L6_AA$Group12       -138.963363   -553.07495   -624.358635
## format_16S_L6_AA$Group13       -138.963363   -915.51028   -624.358635
## dph                              -7.359025    -93.65095     -6.273491
##                               X__.55 Ferritrophicum      X__.56      X__.57
## (Intercept)                889.98365      1121.4188  3083.08018  -331.17417
## format_16S_L6_AA$Group11  3635.61976      9859.1925 10403.86554  3980.75166
## format_16S_L6_AA$Group12 -1211.87325     -3286.3975 -4391.74591 -1326.91722
## format_16S_L6_AA$Group13 -1211.87325     -3286.3975 -1620.37372 -1326.91722
## dph                         16.94156       113.9462    68.87714    87.26797
##                           Aquicella Enterobacter Escherichia.Shigella
## (Intercept)              1407.21134    901983.91           4598077394
## format_16S_L6_AA$Group11 2108.10502  -1283549.85          -2004286454
## format_16S_L6_AA$Group12 -702.70167  -1363305.17          -2007536479
## format_16S_L6_AA$Group13 -702.70167  -1356198.94          -1876594600
## dph                       -37.07946     24292.99           -135404795
##                          Klebsiella  Morganella     Proteus Salmonella
## (Intercept)               689583269   7907.1957  3085141.34   1586.149
## format_16S_L6_AA$Group11 -282419794  63503.8448  -898306.53  -9599.604
## format_16S_L6_AA$Group12 -282932463 -21167.9483 -1490147.46 -65370.547
## format_16S_L6_AA$Group13 -282837610 -21167.9483 -1500219.52 140340.697
## dph                       -21395552    697.9343   -83232.67   3357.074
##                             X__.58 Methylobacter uncultured.31     X__.59
## (Intercept)               90323828      248.2056     -357.3719  3421.8138
## format_16S_L6_AA$Group11 -35758217     6832.8456    35915.6196 24290.1646
## format_16S_L6_AA$Group12 -35827036    -2277.6152   -11971.8732 -8096.7215
## format_16S_L6_AA$Group13 -35822272    -2277.6152   -11971.8732 -8096.7215
## dph                       -2864629      106.8110      648.9076   246.0478
##                              X__.60      X__.61 Haemophilus   Muribacter
## (Intercept)              -1605.6355   27.830850  2221218.66  28221.75047
## format_16S_L6_AA$Group11  4417.8478  342.778428 -1433550.32  83029.06700
## format_16S_L6_AA$Group12 -1472.6159 -114.259476 -1897674.52 -27645.62585
## format_16S_L6_AA$Group13 -1472.6159 -114.259476 -1898229.88 -27691.72057
## dph                        162.0132    4.548875   -16922.63    -27.89631
##                          Rodentibacter     X__.62 Acinetobacter Enhydrobacter
## (Intercept)                  -90537.27 -35333.435     -689992.7    -10314.671
## format_16S_L6_AA$Group11    2306286.12 145788.198      460758.9     -5199.064
## format_16S_L6_AA$Group12    -773027.75 -48596.066     -783853.2     -1129.959
## format_16S_L6_AA$Group13    -759043.28 -48596.066     -689181.5    -14407.362
## dph                           45513.28   4417.342       82249.5      1301.160
##                           Moraxella Pseudomonas    Woeseia    Vibrio
## (Intercept)                55885.89    335123.3  412.53817  217981.9
## format_16S_L6_AA$Group11  285287.94   2068472.4 2104.59842 -421622.0
## format_16S_L6_AA$Group12 -468147.10   -784221.5 -701.53281 -421622.0
## format_16S_L6_AA$Group13 -469143.26   -492918.5 -701.53281 -421622.0
## dph                        21750.39     24011.0   15.21024   10717.9
##                          uncultured.32 Luteimonas Lysobacter Pseudoxanthomonas
## (Intercept)                  807.87556   4863.989   235.9395        14131.8711
## format_16S_L6_AA$Group11    1596.43034   4729.523 10201.5790        85652.7121
## format_16S_L6_AA$Group12    -532.14345  -1340.499 -3400.5263       -28469.5506
## format_16S_L6_AA$Group13    -532.14345  -1602.712 -3400.5263       -28591.5807
## dph                          -14.51222   -161.983   166.5572          761.0374
##                          Stenotrophomonas Xanthomonas      X__.63     X__.64
## (Intercept)                     5614.5616    1962.258  4280.17394  1086.6306
## format_16S_L6_AA$Group11       32000.1944   23590.117 17340.43421 13852.2870
## format_16S_L6_AA$Group12      -10666.7315   -7863.372 -5780.14474 -4617.4290
## format_16S_L6_AA$Group13      -10666.7315   -7863.372 -5780.14474 -4617.4290
## dph                              265.9037     310.585    78.94583   185.8315
##                          Sh765B.TzT.35 uncultured.bacterium.37
## (Intercept)                 1148.22086              4667.42026
## format_16S_L6_AA$Group11    9085.35036             18444.83914
## format_16S_L6_AA$Group12   -3028.45012             -6148.27971
## format_16S_L6_AA$Group13   -3028.45012             -6148.27971
## dph                           98.95943                77.93997
##                          uncultured.proteobacterium uncultured.soil.bacterium.2
## (Intercept)                               444.00879                    741.3371
## format_16S_L6_AA$Group11                 2234.32009                  19227.6982
## format_16S_L6_AA$Group12                 -744.77336                  -6409.2327
## format_16S_L6_AA$Group13                 -744.77336                  -6409.2327
## dph                                        15.82971                    298.3103
##                                X__.65 Anaeroplasma uncultured.bacterium.38
## (Intercept)               1914.985291    421701492              -45.405926
## format_16S_L6_AA$Group11  5271.373817   -196908819              256.296008
## format_16S_L6_AA$Group12 -1757.124606   -197000649              -85.432003
## format_16S_L6_AA$Group13 -1757.124606   -196760939              -85.432003
## dph                         -8.308457    -11826309                6.886207
##                          uncultured.organism.2 gut.metagenome.3
## (Intercept)                           152334.3       5301638.03
## format_16S_L6_AA$Group11            -3105177.5      -3506152.40
## format_16S_L6_AA$Group12            -3103942.7      -3506152.40
## format_16S_L6_AA$Group13            -3103718.7      -3506152.40
## dph                                   155412.8        -94499.24
##                          uncultured.bacterium.39 uncultured.rumen.bacterium.2
## (Intercept)                           37344008.1                     5849.431
## format_16S_L6_AA$Group11             -42050433.7                   -42222.254
## format_16S_L6_AA$Group12             -42054546.1                   -42222.254
## format_16S_L6_AA$Group13             -42055170.6                   -42222.254
## dph                                     247955.9                     1914.359
##                              X__.66 Mycoplasma Chthoniobacter
## (Intercept)               3692356.2   531.2442      5657.5906
## format_16S_L6_AA$Group11 -7761808.1  8996.7706      9327.2008
## format_16S_L6_AA$Group12 -7761441.1 -2998.9235     -3109.0669
## format_16S_L6_AA$Group13 -7761808.1 -2998.9235     -3109.0669
## dph                        214181.7   129.8779      -134.1328
##                          Candidatus.Xiphinematobacter uncultured.33      X__.67
## (Intercept)                                146.640735    -269503.64   673.88953
## format_16S_L6_AA$Group11                   189.885265    -337729.87  3316.84084
## format_16S_L6_AA$Group12                   -63.295088    -337729.87 -1105.61361
## format_16S_L6_AA$Group13                   -63.295088    -337729.87 -1105.61361
## dph                                         -4.386613      31959.66    22.72232
##                          Akkermansia uncultured.bacterium.40
## (Intercept)                 42419656              -320.63131
## format_16S_L6_AA$Group11  -193154471              1068.46990
## format_16S_L6_AA$Group12  -194871605              -356.15663
## format_16S_L6_AA$Group13  -194350460              -356.15663
## dph                          8029674                35.62042
## 
## $coef.sites
##                              D01E01C      D01E01D      D01E01I       D01E01J
## (Intercept)              0.909783055  0.879457010  0.874134773  0.8708505600
## format_16S_L6_AA$Group11 0.040471479 -0.042083942  0.012587382 -0.0227470563
## format_16S_L6_AA$Group12 0.041006280 -0.025286579  0.002009072 -0.0296415367
## format_16S_L6_AA$Group13 0.013930842  0.016201777 -0.057644674 -0.0007943556
## dph                      0.002474799  0.003515086  0.003657047  0.0037958001
##                              D01E02C      D01E02D      D01E02I      D01E02J
## (Intercept)              0.931457852  0.930532983  0.893906702  0.874329135
## format_16S_L6_AA$Group11 0.030160209 -0.049441658  0.001563242 -0.045058795
## format_16S_L6_AA$Group12 0.030524943 -0.006250009  0.001232346 -0.027221532
## format_16S_L6_AA$Group13 0.013649416  0.023517119 -0.035307500  0.017921280
## dph                      0.001925275  0.001932740  0.003019762  0.003634385
##                               D01E03C      D01E03D      D01E03I      D01E03J
## (Intercept)               0.915056037  0.915971887  0.883276418  0.910693848
## format_16S_L6_AA$Group11  0.037414529 -0.047941458  0.010978237 -0.043959419
## format_16S_L6_AA$Group12  0.037172418 -0.016469733  0.001361732 -0.021135137
## format_16S_L6_AA$Group13 -0.004463347  0.025757860 -0.055380669  0.024437596
## dph                       0.002228401  0.002353358  0.003358257  0.002518075
##                              D01E04C      D01E04D      D01E04I       D01E04J
## (Intercept)              0.912084259  0.932227565  0.879103786  8.872113e-01
## format_16S_L6_AA$Group11 0.037136892 -0.046460724  0.014109225 -1.681597e-02
## format_16S_L6_AA$Group12 0.037833494 -0.010797893  0.008146186 -3.182243e-02
## format_16S_L6_AA$Group13 0.007405986  0.024484129 -0.061304248  2.552220e-06
## dph                      0.002486364  0.001820865  0.003433234  3.237352e-03
##                              D01E05C      D01E05D      D01E05I      D01E05J
## (Intercept)              0.912872702  0.918365208  0.921658072  0.908419372
## format_16S_L6_AA$Group11 0.035823867 -0.042580805  0.017194893 -0.018428492
## format_16S_L6_AA$Group12 0.036504935 -0.013360349  0.021214906 -0.006553053
## format_16S_L6_AA$Group13 0.011252732  0.020625680 -0.036481812 -0.008048429
## dph                      0.002520298  0.002365551  0.002163789  0.002636189
##                              D01E06C      D01E06D      D01E06I      D01E06J
## (Intercept)              0.936978181  0.889373378  0.868916810  0.873314329
## format_16S_L6_AA$Group11 0.026949395 -0.043644882  0.006720862  0.011870969
## format_16S_L6_AA$Group12 0.027458038 -0.032022465 -0.000128514  0.003074858
## format_16S_L6_AA$Group13 0.011629321  0.019747583 -0.053984924 -0.057415786
## dph                      0.001769606  0.002725577  0.003790079  0.003664943
##                              D01E07C      D01E07D      D01E07I       D01E07J
## (Intercept)              0.910636583  0.868067634  0.889532217  0.8676409684
## format_16S_L6_AA$Group11 0.040576472 -0.011897503  0.019666563 -0.0007120908
## format_16S_L6_AA$Group12 0.040485473 -0.018568197  0.010427360 -0.0112708549
## format_16S_L6_AA$Group13 0.014785009 -0.021372423 -0.059527833 -0.0379628439
## dph                      0.002431383  0.003823105  0.003158742  0.0038770640
##                              D01E08C      D01E08D      D01E08I      D01E08J
## (Intercept)              0.915563921  0.890292098  0.909553396  0.870463664
## format_16S_L6_AA$Group11 0.039146212 -0.047858268  0.023571248 -0.015078256
## format_16S_L6_AA$Group12 0.039858371 -0.022602885  0.018346101 -0.026458782
## format_16S_L6_AA$Group13 0.008355732  0.023118350 -0.056756731 -0.012054259
## dph                      0.002221302  0.003197981  0.002398097  0.003764304
##                              D01E09C      D01E09D      D01E09I      D01E09J
## (Intercept)              0.912353430  0.876876246  0.869635273  0.868577724
## format_16S_L6_AA$Group11 0.040205572 -0.046439986  0.001009768 -0.022920974
## format_16S_L6_AA$Group12 0.040187960 -0.032433403 -0.009001375 -0.030672723
## format_16S_L6_AA$Group13 0.009416595  0.022774557 -0.042004659 -0.001216010
## dph                      0.002323644  0.003421672  0.003818448  0.003837956
##                              D01E10C      D01E10D      D01E10I      D01E10J
## (Intercept)              0.911007540  0.870828596  0.880400191  0.892686242
## format_16S_L6_AA$Group11 0.040458981  0.003456926  0.003996107 -0.038997376
## format_16S_L6_AA$Group12 0.040483423 -0.006646746 -0.007744677 -0.027281472
## format_16S_L6_AA$Group13 0.019242568 -0.044051570 -0.042907221  0.019436656
## dph                      0.002444941  0.003691812  0.003479351  0.003106364
##                                D04E01C       D04E01D      D04E01I       D04E01J
## (Intercept)               8.830358e-01  0.8198736964  0.848113246  0.7931337725
## format_16S_L6_AA$Group11  1.062238e-01 -0.1479441172  0.062684157 -0.1453036417
## format_16S_L6_AA$Group12  9.589481e-02 -0.1470959497  0.026063758 -0.1694303864
## format_16S_L6_AA$Group13 -2.184399e-02  0.1135303502 -0.212837365  0.1058271201
## dph                      -4.560507e-05 -0.0003542764 -0.001846471 -0.0005019011
##                               D04E02C       D04E02D       D04E02I       D04E02J
## (Intercept)              0.8972816233  0.8832521671  8.639587e-01  0.8311275129
## format_16S_L6_AA$Group11 0.0794811485 -0.1092862187  2.710142e-02 -0.1339018315
## format_16S_L6_AA$Group12 0.0777796464 -0.1154983327  2.095579e-02 -0.1780418489
## format_16S_L6_AA$Group13 0.0511279107  0.1054299512 -1.216566e-01  0.1342116429
## dph                      0.0009346193 -0.0001771933 -9.432531e-06 -0.0006043378
##                              D04E03C       D04E03D       D04E03I       D04E03J
## (Intercept)              0.877169137  0.8566827717  0.8394319912  8.750740e-01
## format_16S_L6_AA$Group11 0.093856319 -0.1275958245  0.0122887272 -8.925111e-02
## format_16S_L6_AA$Group12 0.087859297 -0.1383618422  0.0092750282 -1.380023e-01
## format_16S_L6_AA$Group13 0.025018876  0.1187638426 -0.1260219370  1.047486e-01
## dph                      0.001067798 -0.0003011476  0.0001461638  7.817168e-05
##                              D04E04C       D04E04D       D04E04I       D04E04J
## (Intercept)              0.879301276  0.9049431886  0.8137994143  0.8397884357
## format_16S_L6_AA$Group11 0.090668392 -0.0931309305  0.0037919738 -0.0977512401
## format_16S_L6_AA$Group12 0.085234674 -0.0632325913 -0.0103684070 -0.1651965114
## format_16S_L6_AA$Group13 0.026794105  0.0725793844 -0.1615921211  0.0983314261
## dph                      0.001237375  0.0005599219 -0.0009512264 -0.0004009619
##                               D04E05C       D04E05D       D04E05I       D04E05J
## (Intercept)              0.8714212655  0.8975149314  0.8235733140  0.7965347274
## format_16S_L6_AA$Group11 0.1026495261 -0.0903380433 -0.0467712504 -0.1300357166
## format_16S_L6_AA$Group12 0.0957283249 -0.0610963422 -0.0235423468 -0.1272645055
## format_16S_L6_AA$Group13 0.0232230575  0.0643081876 -0.0749319733  0.0616859699
## dph                      0.0008310971  0.0006940097  0.0002124475 -0.0001793451
##                             D04E06C      D04E06D      D04E06I       D04E06J
## (Intercept)              0.89384467  0.802520424  0.870717064  0.7979307422
## format_16S_L6_AA$Group11 0.08032818 -0.164830166  0.079366659 -0.0598213723
## format_16S_L6_AA$Group12 0.07566926 -0.173785115  0.047882428 -0.0451269276
## format_16S_L6_AA$Group13 0.02272648  0.128612332 -0.210852196 -0.0806015728
## dph                      0.00108002 -0.000937552 -0.001719766 -0.0004602621
##                               D04E07C      D04E07D     D04E07I       D04E07J
## (Intercept)              0.8891697609  0.792071545  0.90056473  0.7957814368
## format_16S_L6_AA$Group11 0.0877027993 -0.155368649  0.11025502 -0.1287293293
## format_16S_L6_AA$Group12 0.0822461716 -0.130465440  0.07717781 -0.1163499547
## format_16S_L6_AA$Group13 0.0237844411  0.073852435 -0.22014347  0.0380405509
## dph                      0.0008823748 -0.000731065 -0.00274847 -0.0007945238
##                               D04E08C       D04E08D      D04E08I      D04E08J
## (Intercept)              0.8655777831  0.8396786515  0.903225518  0.800587025
## format_16S_L6_AA$Group11 0.1091817510 -0.1474626105  0.112799800 -0.146427426
## format_16S_L6_AA$Group12 0.1003589401 -0.1684158134  0.080409049 -0.191996473
## format_16S_L6_AA$Group13 0.0062887551  0.1397477672 -0.212922230  0.124685570
## dph                      0.0008192426 -0.0009398015 -0.003101322 -0.001060347
##                             D04E09C       D04E09D       D04E09I      D04E09J
## (Intercept)              0.87889733  0.8328019947  0.8751371650  0.797777805
## format_16S_L6_AA$Group11 0.09477846 -0.1343761722  0.0170999638 -0.148061335
## format_16S_L6_AA$Group12 0.08907883 -0.1237348953  0.0138450211 -0.188015706
## format_16S_L6_AA$Group13 0.02491273  0.0949524807 -0.1173835755  0.120528335
## dph                      0.00103066 -0.0001086337 -0.0001236023 -0.001022094
##                               D04E10C       D04E10D       D04E10I       D04E10J
## (Intercept)               0.872280990  0.8309602523  0.8378283971  0.9264544370
## format_16S_L6_AA$Group11  0.117450516 -0.0704521375 -0.0468977540 -0.0150082626
## format_16S_L6_AA$Group12  0.105763313 -0.0302266181 -0.0325765120 -0.0743862301
## format_16S_L6_AA$Group13 -0.015197317 -0.0333300617 -0.0481965214  0.0307945336
## dph                      -0.000112465  0.0005869571  0.0006349245  0.0007451802
##                                D07E01C       D07E01D       D07E01I      D07E01J
## (Intercept)               0.8914113186  0.8007706921  0.8038956545  0.799555184
## format_16S_L6_AA$Group11  0.1037322363 -0.1679032366 -0.0491964958 -0.138933242
## format_16S_L6_AA$Group12  0.0957925525 -0.1729663665 -0.0474795802 -0.182741318
## format_16S_L6_AA$Group13  0.0139969067  0.1287903645 -0.0944153608  0.110826026
## dph                      -0.0002067482 -0.0009636864 -0.0009620337 -0.000882072
##                               D07E02C       D07E02D       D07E02I      D07E02J
## (Intercept)              0.8965270648  0.8851469731  0.8085309420  0.829140099
## format_16S_L6_AA$Group11 0.0930309237 -0.1113409298 -0.0581642987 -0.124762888
## format_16S_L6_AA$Group12 0.0878001479 -0.0904522748 -0.0497496088 -0.200148442
## format_16S_L6_AA$Group13 0.0266418849  0.0933719405 -0.0749804422  0.134779092
## dph                      0.0002224805  0.0002927066 -0.0006111623 -0.001179341
##                                D07E03C       D07E03D      D07E03I       D07E03J
## (Intercept)               0.9075083582  0.7946824084  0.872416568  0.9167249560
## format_16S_L6_AA$Group11  0.0953922257 -0.1645989511  0.086191960 -0.0304355712
## format_16S_L6_AA$Group12  0.0933996510 -0.1476327670  0.050131276 -0.0916938871
## format_16S_L6_AA$Group13  0.0506072214  0.1006888170 -0.228707469  0.0474342263
## dph                      -0.0009432836 -0.0007254797 -0.002310364  0.0004141123
##                                D07E04C       D07E04D       D07E04I
## (Intercept)               0.8896869167  0.7946698312  0.8187354921
## format_16S_L6_AA$Group11  0.1042602522 -0.0947246364 -0.0009475732
## format_16S_L6_AA$Group12  0.0947648235 -0.0542435869 -0.0142625474
## format_16S_L6_AA$Group13 -0.0041375444 -0.0466281995 -0.1532650166
## dph                      -0.0002172806 -0.0005858853 -0.0010377654
##                                D07E04J      D07E05C       D07E05D       D07E05I
## (Intercept)               0.8346887027  0.891925342  0.7922854134  0.8146928796
## format_16S_L6_AA$Group11 -0.0701144408  0.101832312 -0.1353095975 -0.0720792350
## format_16S_L6_AA$Group12 -0.0656085576  0.093820023 -0.0932137796 -0.0534620977
## format_16S_L6_AA$Group13 -0.0240037309  0.018708066  0.0186742070 -0.0486591261
## dph                      -0.0003943318 -0.000503794 -0.0008562995 -0.0006002498
##                                D07E05J       D07E06C       D07E06D      D07E06I
## (Intercept)               9.039062e-01  0.9112981139  0.7908393041  0.849234069
## format_16S_L6_AA$Group11 -5.409138e-02  0.0881903448 -0.1431626869  0.028952717
## format_16S_L6_AA$Group12 -1.179824e-01  0.0821047287 -0.0950628654  0.001255496
## format_16S_L6_AA$Group13  7.693362e-02  0.0257242213  0.0275247625 -0.184357456
## dph                       1.116384e-05 -0.0005608465 -0.0007875187 -0.002330473
##                               D07E06J      D07E07C      D07E07D       D07E07I
## (Intercept)               0.811332687  0.892691964  0.856833148  0.8248067720
## format_16S_L6_AA$Group11 -0.038984662  0.121424588 -0.130898190  0.0007874315
## format_16S_L6_AA$Group12 -0.041885951  0.117440344 -0.166900617 -0.0152939618
## format_16S_L6_AA$Group13 -0.106392214  0.060683541  0.134365728 -0.1566506538
## dph                      -0.001252125 -0.001097022 -0.001150323 -0.0015329334
##                               D07E07J       D07E08C      D07E08D      D07E08I
## (Intercept)               0.801538848  0.8798648370  0.794058805  0.827672447
## format_16S_L6_AA$Group11 -0.144355770  0.1169231630 -0.129521927  0.006444509
## format_16S_L6_AA$Group12 -0.185856497  0.1070344918 -0.087105328 -0.006785753
## format_16S_L6_AA$Group13  0.118607065  0.0069850665  0.007697464 -0.161883977
## dph                      -0.001024573 -0.0004286243 -0.000926428 -0.001325810
##                               D07E08J       D07E09C      D07E09D      D07E09I
## (Intercept)               0.805198183  0.8980305259  0.803103331  0.879522394
## format_16S_L6_AA$Group11 -0.053703542  0.1131319958 -0.071769875  0.078588500
## format_16S_L6_AA$Group12 -0.049564134  0.1025579378 -0.046141213  0.039643309
## format_16S_L6_AA$Group13 -0.088980366  0.0002653627 -0.077140973 -0.229013162
## dph                      -0.001096771 -0.0016611196 -0.001067654 -0.003014587
##                               D07E09J       D07E10C       D07E10D      D07E10I
## (Intercept)               0.911390988  0.8896428956  0.7949676578  0.945557645
## format_16S_L6_AA$Group11 -0.072272337  0.1044671251 -0.1124275699  0.086556119
## format_16S_L6_AA$Group12 -0.105852336  0.0974293544 -0.0711103347  0.063071430
## format_16S_L6_AA$Group13  0.084551771  0.0218853702 -0.0220317354 -0.176408310
## dph                      -0.000286782 -0.0001409189 -0.0009333163 -0.003087437
##                               D07E10J       D14E01C      D14E01D      D14E01I
## (Intercept)               0.821662544  0.9175497205  0.820072038  0.899679008
## format_16S_L6_AA$Group11 -0.134419066  0.0885720837 -0.164624703  0.092999819
## format_16S_L6_AA$Group12 -0.184711870  0.0842221346 -0.178127983  0.053606893
## format_16S_L6_AA$Group13  0.123226082  0.0295734403  0.142055486 -0.234043398
## dph                      -0.001142918 -0.0006570346 -0.001275341 -0.003152739
##                                D14E01J      D14E02C       D14E02D      D14E02I
## (Intercept)               0.7996246628  0.896128131  0.7953750664  0.825610788
## format_16S_L6_AA$Group11 -0.0962820278  0.123293976 -0.1706049521 -0.009849589
## format_16S_L6_AA$Group12 -0.0827516434  0.114350572 -0.1475635888 -0.021786977
## format_16S_L6_AA$Group13 -0.0222855803  0.023404360  0.1055862321 -0.143994829
## dph                      -0.0008848695 -0.001542903 -0.0007982339 -0.001595052
##                                D14E02J      D14E03C       D14E03D       D14E03I
## (Intercept)               0.7960203726  0.908756520  0.9773199126  0.8084847987
## format_16S_L6_AA$Group11 -0.1209979261  0.131907053 -0.0228021444 -0.0253894787
## format_16S_L6_AA$Group12 -0.1026316024  0.124493712 -0.0167950903 -0.0304873381
## format_16S_L6_AA$Group13  0.0152848200  0.036175526  0.0192810034 -0.1138208942
## dph                      -0.0009583799 -0.002882568  0.0001216423 -0.0004498502
##                               D14E03J      D14E04C       D14E04D      D14E04I
## (Intercept)               0.809066262  0.903961338  0.8012070169  0.826024843
## format_16S_L6_AA$Group11 -0.142455538  0.108428705 -0.1573975599 -0.025528315
## format_16S_L6_AA$Group12 -0.196373160  0.101974903 -0.1447708706 -0.029766569
## format_16S_L6_AA$Group13  0.129059057  0.030341687  0.0937380471 -0.112944896
## dph                      -0.001251157 -0.001047594 -0.0009174998 -0.001041295
##                               D14E04J      D14E05C      D14E05D      D14E05I
## (Intercept)               0.908021459  0.899709643  0.883653251  0.863945357
## format_16S_L6_AA$Group11  0.102441892  0.118536062 -0.113601221  0.018916086
## format_16S_L6_AA$Group12  0.062534382  0.109900259 -0.114498037  0.001764223
## format_16S_L6_AA$Group13 -0.236406723  0.025135471  0.106917632 -0.149740019
## dph                      -0.003468713 -0.001497774 -0.000296022 -0.001246126
##                                D14E05J      D14E06C      D14E06D      D14E06I
## (Intercept)               0.7990596346  0.895646755  0.799973355  0.921872738
## format_16S_L6_AA$Group11 -0.1405280503  0.122250462 -0.170178270  0.106275953
## format_16S_L6_AA$Group12 -0.1459317949  0.113988593 -0.163354154  0.072289460
## format_16S_L6_AA$Group13  0.0771173490  0.023500261  0.119840002 -0.227589394
## dph                      -0.0009075772 -0.001599671 -0.001042977 -0.003533278
##                               D14E06J      D14E07C       D14E07D      D14E07I
## (Intercept)               0.806242257  0.911645479  0.7956827809  0.908166949
## format_16S_L6_AA$Group11 -0.145493987  0.126697026 -0.1290012606  0.105604241
## format_16S_L6_AA$Group12 -0.196149393  0.117509252 -0.0848620289  0.064951414
## format_16S_L6_AA$Group13  0.128777697  0.034436159  0.0057108261 -0.243859236
## dph                      -0.001283626 -0.002663282 -0.0009816709 -0.003599447
##                               D14E07J      D14E08C       D14E08D      D14E08I
## (Intercept)               0.872346175  0.903512144  0.8694769665  0.929868599
## format_16S_L6_AA$Group11  0.058673867  0.131947576 -0.1278024075  0.103215924
## format_16S_L6_AA$Group12  0.017338347  0.121454263 -0.1468028855  0.070579748
## format_16S_L6_AA$Group13 -0.207209516  0.022194359  0.1264096282 -0.219039917
## dph                      -0.002925244 -0.002508531 -0.0009930918 -0.003526552
##                               D14E08J      D14E09C      D14E09D      D14E09I
## (Intercept)               0.853260275  0.902598308  0.819392516  0.929740159
## format_16S_L6_AA$Group11 -0.118188263  0.112221293 -0.160412079  0.079839686
## format_16S_L6_AA$Group12 -0.189001330  0.107069822 -0.183297481  0.055132971
## format_16S_L6_AA$Group13  0.137099050  0.057937056  0.142479981 -0.169136451
## dph                      -0.001325737 -0.001243518 -0.001269723 -0.002257848
##                               D14E09J      D14E10C       D14E10D      D14E10I
## (Intercept)               0.827524340  0.924063599  9.127411e-01  0.937538162
## format_16S_L6_AA$Group11 -0.136862164  0.109492116 -8.704744e-02  0.069645345
## format_16S_L6_AA$Group12 -0.201523452  0.100303601 -8.067691e-02  0.049662757
## format_16S_L6_AA$Group13  0.141777488  0.014986513  7.984490e-02 -0.136434371
## dph                      -0.001437176 -0.002847235 -5.533981e-05 -0.001915766
##                                D14E10J      D21E01C      D21E01D      D21E01I
## (Intercept)               9.800042e-01  0.952727412  0.839339534  0.911170138
## format_16S_L6_AA$Group11 -9.886108e-03  0.096470989 -0.139907980  0.098765539
## format_16S_L6_AA$Group12 -2.648544e-02  0.097809259 -0.041863777  0.072880769
## format_16S_L6_AA$Group13  1.770287e-02  0.068434355  0.005742739 -0.229972524
## dph                       6.713705e-05 -0.003164586 -0.001826082 -0.003518213
##                              D21E01J     D21E02C       D21E02D      D21E02I
## (Intercept)               0.79552390  0.93515658  0.7945577511  0.922182710
## format_16S_L6_AA$Group11 -0.13240031  0.10093119 -0.1514669661  0.100991063
## format_16S_L6_AA$Group12 -0.11297759  0.09603056 -0.1062110178  0.067952352
## format_16S_L6_AA$Group13  0.03407343  0.02872622  0.0470245571 -0.215124823
## dph                      -0.00101701 -0.00228422 -0.0008924981 -0.003145826
##                               D21E02J      D21E03C       D21E03D      D21E03I
## (Intercept)               0.883452694  0.925979223  0.8664121783  0.867961560
## format_16S_L6_AA$Group11 -0.097340133  0.117521367 -0.1371937218  0.056301963
## format_16S_L6_AA$Group12 -0.153086013  0.112551115 -0.1326894784  0.014374494
## format_16S_L6_AA$Group13  0.114666053  0.043251426  0.1224014781 -0.206434290
## dph                      -0.001072201 -0.002956399 -0.0008194783 -0.002842395
##                               D21E03J     D21E04C       D21E04D      D21E04I
## (Intercept)               0.831353113  0.94796424  0.8474548965  0.880716392
## format_16S_L6_AA$Group11 -0.134217348  0.09202197 -0.1486363168  0.085750739
## format_16S_L6_AA$Group12 -0.201855698  0.09452401 -0.1578059947  0.043079851
## format_16S_L6_AA$Group13  0.142771365  0.04994475  0.1369096560 -0.234193965
## dph                      -0.001448869 -0.00324706 -0.0009918272 -0.002913862
##                                D21E04J      D21E05C       D21E05D      D21E05I
## (Intercept)               0.8930272178  0.926995778  0.8221213480  0.804856607
## format_16S_L6_AA$Group11 -0.0799344017  0.109903794 -0.1627776756 -0.068647516
## format_16S_L6_AA$Group12 -0.1401782887  0.103742942 -0.1484682837 -0.057029214
## format_16S_L6_AA$Group13  0.1033065962  0.028725691  0.1260700004 -0.070121042
## dph                      -0.0005567689 -0.002822083 -0.0005886651 -0.001125671
##                               D21E05J      D21E06C      D21E06D      D21E06I
## (Intercept)               0.831967470  0.935431107  0.814309044  0.948214309
## format_16S_L6_AA$Group11 -0.133523822  0.087937246 -0.041614074  0.081380975
## format_16S_L6_AA$Group12 -0.200997839  0.085772469 -0.025902489  0.059713957
## format_16S_L6_AA$Group13  0.141651134  0.060863373 -0.112202538 -0.162577000
## dph                      -0.001459959 -0.001494425 -0.001163207 -0.002826854
##                              D21E06J      D21E07C       D21E07D      D21E07I
## (Intercept)               0.88911116  0.905814893  0.8524930300  0.881261284
## format_16S_L6_AA$Group11 -0.07862724  0.115161638 -0.1239292490  0.022218984
## format_16S_L6_AA$Group12 -0.12217830  0.110088216 -0.1065323995  0.007148667
## format_16S_L6_AA$Group13  0.08557670  0.043277688  0.0770301496 -0.135432394
## dph                      -0.00039275 -0.001491894 -0.0006991985 -0.001042395
##                                D21E07J      D21E08C      D21E08D      D21E08I
## (Intercept)               0.9209745370  0.925514767  0.959420037  0.865502435
## format_16S_L6_AA$Group11 -0.0494421421  0.110712420 -0.123621137  0.027164995
## format_16S_L6_AA$Group12 -0.1036514076  0.107469203 -0.015595420  0.014825528
## format_16S_L6_AA$Group13  0.0705654548  0.061633670  0.060769446 -0.184256677
## dph                      -0.0002238381 -0.002435734 -0.002082828 -0.002576923
##                               D21E08J      D21E09C      D21E09D     D21E09I
## (Intercept)               0.831830072  0.930648787  0.909900330  0.91343564
## format_16S_L6_AA$Group11 -0.130985462  0.117172079 -0.154698244  0.05211483
## format_16S_L6_AA$Group12 -0.181411647  0.112549101 -0.060463935  0.03931466
## format_16S_L6_AA$Group13  0.126525925  0.049240915  0.081995355 -0.17594984
## dph                      -0.001156157 -0.003221509 -0.002564087 -0.00294050
##                               D21E09J      D21E10C      D21E10D      D21E10I
## (Intercept)               0.868559565  0.932105852  0.851826099  0.934038896
## format_16S_L6_AA$Group11 -0.103826842  0.110359083 -0.128000693  0.047717664
## format_16S_L6_AA$Group12 -0.177849565  0.106441165 -0.033250547  0.039993778
## format_16S_L6_AA$Group13  0.128466439  0.050343458 -0.007369474 -0.143805734
## dph                      -0.001219215 -0.002858992 -0.002177683 -0.002570563
##                               D21E10J      D28E01C      D28E01D      D28E01I
## (Intercept)               0.867016427  0.965691522  0.878211988  0.926018766
## format_16S_L6_AA$Group11 -0.109190879  0.072863961 -0.152665686  0.103777083
## format_16S_L6_AA$Group12 -0.178782288  0.073832277 -0.067366278  0.078714272
## format_16S_L6_AA$Group13  0.130751018  0.063022301  0.062177841 -0.213690874
## dph                      -0.001353611 -0.002443154 -0.002491542 -0.003542932
##                               D28E01J      D28E02C      D28E02D      D28E02I
## (Intercept)               0.809668181  0.971590249  0.834864595  0.902127755
## format_16S_L6_AA$Group11 -0.149542672  0.080762057 -0.138903773  0.099913502
## format_16S_L6_AA$Group12 -0.189445412  0.082943188 -0.040405404  0.074343212
## format_16S_L6_AA$Group13  0.128466094  0.071274677 -0.002112771 -0.225779881
## dph                      -0.001327758 -0.003148254 -0.001901269 -0.003010815
##                                D28E02J      D28E03C      D28E03D      D28E03I
## (Intercept)               0.8868033419  0.956440115  0.863247655  0.875891798
## format_16S_L6_AA$Group11 -0.0909187735  0.086121078 -0.135833021  0.024277307
## format_16S_L6_AA$Group12 -0.1474420928  0.087029630 -0.040233038  0.023428154
## format_16S_L6_AA$Group13  0.1112441696  0.074932876  0.014094985 -0.185208827
## dph                      -0.0007781663 -0.002614637 -0.002259824 -0.003294531
##                               D28E03J      D28E04C      D28E04D      D28E04I
## (Intercept)               0.804864611  0.964527478  0.886258163  0.888082337
## format_16S_L6_AA$Group11 -0.149448210  0.088364588  0.059253838  0.052503872
## format_16S_L6_AA$Group12 -0.189215737  0.089964134  0.046867814  0.036687877
## format_16S_L6_AA$Group13  0.124902174  0.075453288 -0.211380398 -0.206008520
## dph                      -0.001272235 -0.003232095 -0.003428014 -0.003569711
##                               D28E04J      D28E05C      D28E05D      D28E05I
## (Intercept)               0.807435672  0.932310452  0.808105987  0.893468501
## format_16S_L6_AA$Group11 -0.148180282  0.087911735 -0.097587491  0.067656158
## format_16S_L6_AA$Group12 -0.191784604  0.088337966 -0.042494107  0.047637428
## format_16S_L6_AA$Group13  0.127149302  0.070987811 -0.053559054 -0.221164011
## dph                      -0.001346064 -0.001408386 -0.001234687 -0.003714417
##                               D28E05J      D28E06C     D28E06D       D28E06I
## (Intercept)               0.808062764  0.957955088  0.80552599  0.7733990511
## format_16S_L6_AA$Group11 -0.147684902  0.092461838 -0.17477869 -0.1255708436
## format_16S_L6_AA$Group12 -0.195198645  0.093408081 -0.12191134 -0.1187128571
## format_16S_L6_AA$Group13  0.130349686  0.086106182  0.08381950  0.0368272338
## dph                      -0.001352381 -0.002912451 -0.00145261  0.0003246237
##                                D28E06J      D28E07C      D28E07D      D28E07I
## (Intercept)               0.7901317782  0.972279371  0.829729745  0.821932616
## format_16S_L6_AA$Group11 -0.1386431284  0.079236949 -0.183506196  0.002081184
## format_16S_L6_AA$Group12 -0.1188388208  0.082649294 -0.105310649 -0.001660226
## format_16S_L6_AA$Group13  0.0444500377  0.064368255  0.089943972 -0.168649207
## dph                      -0.0007885489 -0.003106058 -0.001995864 -0.001562737
##                                D28E07J      D28E08C       D28E08D      D28E08I
## (Intercept)               9.614654e-01  0.956430272  0.9207274281  0.919596944
## format_16S_L6_AA$Group11 -2.702390e-02  0.080705090 -0.1152723618  0.106244318
## format_16S_L6_AA$Group12 -4.992247e-02  0.079965785 -0.0422380182  0.080761013
## format_16S_L6_AA$Group13  3.707897e-02  0.061549583  0.0723281513 -0.223364375
## dph                      -7.796732e-05 -0.002234859 -0.0003558038 -0.003481564
##                               D28E08J      D28E09C      D28E09D      D28E09I
## (Intercept)               0.865027763  0.965558141  0.829086784  0.864833240
## format_16S_L6_AA$Group11 -0.116314945  0.073475188 -0.111211173  0.048877495
## format_16S_L6_AA$Group12 -0.163061425  0.074440539 -0.029149790  0.043641023
## format_16S_L6_AA$Group13  0.126559488  0.066572987 -0.046763685 -0.188648583
## dph                      -0.001015815 -0.002197382 -0.002076119 -0.001928984
##                               D28E09J      D28E10C      D28E10D      D28E10I
## (Intercept)               0.823961641  0.932156260  0.851649576  0.849027040
## format_16S_L6_AA$Group11 -0.142644786  0.096399575 -0.182957116 -0.147633350
## format_16S_L6_AA$Group12 -0.198411333  0.096304797 -0.125642124 -0.098639633
## format_16S_L6_AA$Group13  0.140791153  0.085264953  0.128912743  0.079538439
## dph                      -0.001458666 -0.001778321 -0.001835697 -0.001218794
##                               D28E10J      D35E01C      D35E01D      D35E01I
## (Intercept)               0.851565218  0.948140132  0.970333733  0.905184243
## format_16S_L6_AA$Group11 -0.125110815  0.098849840 -0.115886547  0.100333501
## format_16S_L6_AA$Group12 -0.180283019  0.100239659 -0.004491418  0.069835369
## format_16S_L6_AA$Group13  0.136315228  0.084225812  0.052485774 -0.248464026
## dph                      -0.001181163 -0.002831278 -0.002093522 -0.003928987
##                               D35E01J      D35E02C      D35E02D      D35E02I
## (Intercept)               0.828927622  0.950851623  0.917559689  0.924331741
## format_16S_L6_AA$Group11 -0.138622992  0.098445143 -0.145644714  0.039980122
## format_16S_L6_AA$Group12 -0.198568599  0.099699121 -0.081984453  0.037318141
## format_16S_L6_AA$Group13  0.143287272  0.085302761  0.101417118 -0.143637469
## dph                      -0.001351019 -0.002877496 -0.002404691 -0.002240842
##                               D35E02J      D35E03C      D35E03D      D35E03I
## (Intercept)               0.857847523  0.970244490  0.817360497  0.927683480
## format_16S_L6_AA$Group11 -0.117293879  0.065245359 -0.121410235  0.105454746
## format_16S_L6_AA$Group12 -0.183701838  0.069410650 -0.041990805  0.080973965
## format_16S_L6_AA$Group13  0.135335955  0.044611520 -0.033899600 -0.211539691
## dph                      -0.001325264 -0.003150368 -0.001861052 -0.003600461
##                               D35E03J      D35E04C      D35E04D      D35E04I
## (Intercept)               0.796331726  0.963225238  0.926340382  0.914392347
## format_16S_L6_AA$Group11 -0.121475163  0.082740659 -0.152852374  0.097834072
## format_16S_L6_AA$Group12 -0.096594622  0.086807878 -0.054570342  0.078235754
## format_16S_L6_AA$Group13  0.008400419  0.046768669  0.088327732 -0.179187068
## dph                      -0.001084514 -0.003371999 -0.002540154 -0.002490329
##                                D35E04J      D35E05C      D35E05D      D35E05I
## (Intercept)               0.9003453134  0.981051728  0.899237940  0.911382223
## format_16S_L6_AA$Group11 -0.0727305893  0.072631965 -0.145369127  0.108114241
## format_16S_L6_AA$Group12 -0.1297023936  0.077846479 -0.085839114  0.084071708
## format_16S_L6_AA$Group13  0.0954507609  0.050915609  0.105509772 -0.204163586
## dph                      -0.0004194627 -0.003372794 -0.001384165 -0.003999836
##                               D35E05J      D35E06C      D35E06D      D35E06I
## (Intercept)               0.862360723  0.933599804  0.864302414  0.805931865
## format_16S_L6_AA$Group11  0.052353538  0.112534203 -0.172199480 -0.129421367
## format_16S_L6_AA$Group12  0.012394535  0.109867568 -0.132161471 -0.070921563
## format_16S_L6_AA$Group13 -0.203845977  0.060424520  0.132326808 -0.004093422
## dph                      -0.002730109 -0.002984647 -0.002048982 -0.001497317
##                               D35E06J      D35E07C      D35E07D       D35E07I
## (Intercept)               0.820506846  0.931233025  0.963994679  8.388489e-01
## format_16S_L6_AA$Group11 -0.028962174  0.111536926 -0.109703910 -3.200574e-02
## format_16S_L6_AA$Group12 -0.028897473  0.109528136 -0.020005172 -4.162002e-05
## format_16S_L6_AA$Group13 -0.125152927  0.062850471  0.058575270 -1.171757e-01
## dph                      -0.001644509 -0.002765543 -0.001908629 -1.181303e-03
##                               D35E07J      D35E08C      D35E08D      D35E08I
## (Intercept)               0.867880342  0.910102611  0.843442091  0.936851406
## format_16S_L6_AA$Group11 -0.103215713  0.109703721 -0.179659246  0.103315187
## format_16S_L6_AA$Group12 -0.176714728  0.103471961 -0.137628609  0.086654641
## format_16S_L6_AA$Group13  0.127936510  0.025962804  0.130468408 -0.100891229
## dph                      -0.001117525 -0.001895716 -0.001806351 -0.003246082
##                               D35E08J     D35E09C     D35E09D      D35E09I
## (Intercept)               0.963210787  0.97853543  0.84250990  0.916528783
## format_16S_L6_AA$Group11  0.062213970  0.06383491 -0.18231775  0.102504894
## format_16S_L6_AA$Group12  0.049456502  0.06883232 -0.11390118  0.074286863
## format_16S_L6_AA$Group13 -0.100234233  0.05195085  0.10034930 -0.231488943
## dph                      -0.002551607 -0.00318544 -0.00243916 -0.003824053
##                               D35E09J     D35E10C      D35E10D      D35E10I
## (Intercept)               0.837082007  0.94753795  0.826197601  0.872871819
## format_16S_L6_AA$Group11 -0.129717716  0.10399809 -0.178197091  0.034672897
## format_16S_L6_AA$Group12 -0.199676850  0.10574883 -0.160682795  0.039610920
## format_16S_L6_AA$Group13  0.140912732  0.08246402  0.131322232 -0.156517442
## dph                      -0.001490987 -0.00322136 -0.002041749 -0.001300769
##                                D35E10J      D42E01C      D42E01D      D42E01I
## (Intercept)               0.7917355982  0.952049796  0.803641027  0.911249612
## format_16S_L6_AA$Group11 -0.1531784972  0.095941298 -0.128117710  0.099045562
## format_16S_L6_AA$Group12 -0.1666359882  0.097168021 -0.066705866  0.068799236
## format_16S_L6_AA$Group13  0.1029384912  0.065234948 -0.007653035 -0.244083252
## dph                      -0.0008547108 -0.003187472 -0.001207756 -0.004035523
##                               D42E01J      D42E02C      D42E02D      D42E02I
## (Intercept)               0.892412812  0.954769765  0.822315341  0.936568103
## format_16S_L6_AA$Group11  0.084868675  0.081008490 -0.182005052  0.098709367
## format_16S_L6_AA$Group12  0.044024943  0.084682455 -0.152299886  0.069386533
## format_16S_L6_AA$Group13 -0.232540903  0.038289323  0.123681755 -0.209357638
## dph                      -0.003427128 -0.003310513 -0.002046994 -0.003609823
##                              D42E02J      D42E03C      D42E03D     D42E03I
## (Intercept)               0.87510503  0.958017946  0.924331794  0.94427054
## format_16S_L6_AA$Group11 -0.09833789  0.084061421 -0.152143449  0.08878916
## format_16S_L6_AA$Group12 -0.17040562  0.086834642 -0.054936087  0.06584742
## format_16S_L6_AA$Group13  0.12379859  0.058413875  0.084356835 -0.17028613
## dph                      -0.00111754 -0.003237606 -0.002675245 -0.00313821
##                               D42E03J     D42E04C      D42E04D     D42E04I
## (Intercept)               0.853044183  0.93600862  0.839365708  0.88857482
## format_16S_L6_AA$Group11  0.025766263  0.10887221 -0.065737400  0.08506919
## format_16S_L6_AA$Group12 -0.001214611  0.10942488 -0.007594568  0.04511579
## format_16S_L6_AA$Group13 -0.180330246  0.07471805 -0.098522530 -0.23585984
## dph                      -0.002522351 -0.00286201 -0.002208344 -0.00337583
##                               D42E04J      D42E05C      D42E05D     D42E05I
## (Intercept)               0.811191440  0.948121628  0.967215885  0.94341648
## format_16S_L6_AA$Group11 -0.143403857  0.098562417  0.051222213  0.09120581
## format_16S_L6_AA$Group12 -0.199226178  0.100382882  0.043853647  0.06872290
## format_16S_L6_AA$Group13  0.132856170  0.063784971 -0.083034891 -0.18812102
## dph                      -0.001356545 -0.003178977 -0.002164911 -0.00347616
##                               D42E05J      D42E06C      D42E06D     D42E06I
## (Intercept)               0.810589378  0.945658332  0.858193078  0.93317438
## format_16S_L6_AA$Group11 -0.049521752  0.105595629  0.030040916  0.10127753
## format_16S_L6_AA$Group12 -0.044618361  0.104247442  0.007372555  0.07003270
## format_16S_L6_AA$Group13 -0.096007125  0.060575554 -0.185234978 -0.21543862
## dph                      -0.001290493 -0.003558595 -0.002605348 -0.00364724
##                               D42E06J     D42E07C      D42E07D      D42E07I
## (Intercept)               0.867041665  0.91461750  0.802203696  0.909434075
## format_16S_L6_AA$Group11  0.049690296  0.12992103 -0.146449224  0.100942588
## format_16S_L6_AA$Group12  0.009584406  0.12447227 -0.110813115  0.064040178
## format_16S_L6_AA$Group13 -0.198768093  0.04632577  0.046859090 -0.243918529
## dph                      -0.002840925 -0.00293659 -0.001267031 -0.003804959
##                               D42E07J      D42E08C      D42E08D      D42E08I
## (Intercept)               0.928013108  0.961654966  0.822155286  0.937004826
## format_16S_L6_AA$Group11  0.104096732  0.085323871 -0.173251675  0.097775398
## format_16S_L6_AA$Group12  0.069903030  0.088724699 -0.153275865  0.069148834
## format_16S_L6_AA$Group13 -0.222334347  0.061085831  0.128198983 -0.205985311
## dph                      -0.003644032 -0.003537896 -0.001327332 -0.003546454
##                              D42E08J     D42E09C      D42E09D      D42E09I
## (Intercept)               0.81152812  0.95254465  0.922739854  0.888210630
## format_16S_L6_AA$Group11 -0.14524054  0.09276380 -0.102844693  0.098422229
## format_16S_L6_AA$Group12 -0.19948879  0.09556484 -0.022658887  0.058569506
## format_16S_L6_AA$Group13  0.13467746  0.05876643  0.019769365 -0.244147405
## dph                      -0.00138194 -0.00325069 -0.002285981 -0.003137764
##                               D42E09J      D42E10C      D42E10D      D42E10I
## (Intercept)               0.797100169  0.935752498  0.872643675  0.923895177
## format_16S_L6_AA$Group11 -0.110844203  0.097768870 -0.169552761  0.104454534
## format_16S_L6_AA$Group12 -0.067567486  0.096746121 -0.123411633  0.072337792
## format_16S_L6_AA$Group13 -0.027339757  0.050659963  0.117686402 -0.226181839
## dph                      -0.001168044 -0.002733758 -0.002750744 -0.003569826
##                               D42E10J
## (Intercept)               0.862378421
## format_16S_L6_AA$Group11  0.042276348
## format_16S_L6_AA$Group12  0.006085813
## format_16S_L6_AA$Group13 -0.192518794
## dph                      -0.002744578
## 
## $f.perms
##              [,1]      [,2]
##    [1,] 1.1474277 0.7879616
##    [2,] 1.3214872 0.9394104
##    [3,] 0.8706174 0.4513525
##    [4,] 1.0596933 0.7632146
##    [5,] 0.6055842 0.8497952
##    [6,] 0.6754922 1.4980561
##    [7,] 0.9959880 0.3527379
##    [8,] 0.8678801 0.9222675
##    [9,] 0.8449141 1.1819720
##   [10,] 1.2826348 0.7937517
##   [11,] 1.1243048 0.9088261
##   [12,] 0.9946698 0.5741233
##   [13,] 0.8046446 0.8903186
##   [14,] 1.0236400 0.4224168
##   [15,] 0.6661175 1.0474949
##   [16,] 1.0044598 0.6304497
##   [17,] 0.8314194 0.3530277
##   [18,] 1.0413644 0.4322144
##   [19,] 0.9033275 1.1063585
##   [20,] 0.7225939 1.7798388
##   [21,] 0.4535993 0.6939056
##   [22,] 0.6976089 1.5639483
##   [23,] 1.0883720 0.6522899
##   [24,] 0.6835645 0.5692140
##   [25,] 0.6694030 0.7387572
##   [26,] 0.6602100 0.7263277
##   [27,] 0.9566682 1.4687987
##   [28,] 1.3021149 1.3440287
##   [29,] 0.8370524 1.1976271
##   [30,] 0.7837980 1.6271645
##   [31,] 0.5225183 0.8196342
##   [32,] 1.2556205 1.2189102
##   [33,] 0.9308003 0.8926777
##   [34,] 0.8313743 0.6097545
##   [35,] 0.8087622 1.6300475
##   [36,] 0.8411258 0.5508411
##   [37,] 0.8783153 0.9763504
##   [38,] 0.6906747 0.7698534
##   [39,] 0.8686562 0.9214981
##   [40,] 1.3720305 0.8047148
##   [41,] 1.0606507 1.6312440
##   [42,] 0.7523509 2.6887647
##   [43,] 0.7274647 0.5884877
##   [44,] 1.0989358 1.2023381
##   [45,] 0.9621883 0.8075476
##   [46,] 0.7763865 1.1790940
##   [47,] 1.0900122 0.9150616
##   [48,] 0.4242893 0.5279301
##   [49,] 1.1777757 1.1288678
##   [50,] 0.7714676 0.8927342
##   [51,] 1.0418055 0.6612640
##   [52,] 1.2466098 1.3903570
##   [53,] 1.0944384 1.0522887
##   [54,] 1.9001417 0.6598888
##   [55,] 1.5615979 0.7354697
##   [56,] 1.7852530 0.5630247
##   [57,] 1.2022040 2.1066171
##   [58,] 1.0190963 0.6278086
##   [59,] 0.6500758 0.5544029
##   [60,] 0.7451334 1.0474853
##   [61,] 1.3369826 1.2276287
##   [62,] 0.6899295 1.1898610
##   [63,] 1.2988616 0.7802326
##   [64,] 1.7261072 1.7602764
##   [65,] 0.7214071 1.1638064
##   [66,] 0.7643024 0.9027071
##   [67,] 0.7555693 0.5940142
##   [68,] 1.3556761 0.7636759
##   [69,] 1.2748395 0.7656610
##   [70,] 1.1746719 1.0276729
##   [71,] 1.4457708 0.4088867
##   [72,] 0.7276796 2.1833565
##   [73,] 1.0631471 2.1109888
##   [74,] 1.1198640 1.8685569
##   [75,] 1.4319495 1.5864809
##   [76,] 1.0525344 0.9150427
##   [77,] 1.0870692 0.8448492
##   [78,] 0.9556136 1.6654848
##   [79,] 0.9535072 0.7590806
##   [80,] 0.8167556 0.6230101
##   [81,] 0.9330250 0.4167449
##   [82,] 1.1496589 0.4178430
##   [83,] 0.8900438 0.5809648
##   [84,] 0.9424746 0.5150557
##   [85,] 1.4665054 2.2293152
##   [86,] 0.9506665 1.5859052
##   [87,] 1.0570678 1.7957362
##   [88,] 0.9141049 0.8519073
##   [89,] 1.2038706 0.7916754
##   [90,] 1.0400996 1.0183475
##   [91,] 1.1592751 0.8262717
##   [92,] 1.6278700 1.3617161
##   [93,] 0.9945197 0.6863818
##   [94,] 0.9418181 0.9195019
##   [95,] 1.0928582 1.3795380
##   [96,] 0.9492251 0.8041297
##   [97,] 1.0018843 1.8458558
##   [98,] 1.0933359 0.7297811
##   [99,] 0.8974995 1.1791858
##  [100,] 0.8089502 0.9030236
##  [101,] 0.7544108 1.7409035
##  [102,] 0.8656283 0.3747241
##  [103,] 0.8843797 0.6729252
##  [104,] 1.1091676 1.3785192
##  [105,] 0.7581520 1.8942335
##  [106,] 0.9038129 1.7085283
##  [107,] 0.9723237 1.1227703
##  [108,] 0.8419818 0.7469864
##  [109,] 1.0829522 0.6295998
##  [110,] 1.1796020 0.8592246
##  [111,] 0.9729605 0.9853193
##  [112,] 0.8322767 0.7110919
##  [113,] 0.9277330 2.2655677
##  [114,] 0.6287507 1.5979304
##  [115,] 1.0984488 0.8623215
##  [116,] 1.0104079 0.8177814
##  [117,] 0.8609428 1.2428380
##  [118,] 0.6299005 0.7952946
##  [119,] 0.9434646 1.1138242
##  [120,] 0.5857030 1.1254275
##  [121,] 1.0194099 1.2486859
##  [122,] 0.6972471 1.0569132
##  [123,] 1.0583103 1.0313619
##  [124,] 1.4598282 0.6853015
##  [125,] 1.0892490 0.5385887
##  [126,] 0.7864491 0.8313159
##  [127,] 0.5439198 1.4224839
##  [128,] 1.0607700 0.4966792
##  [129,] 1.0399181 0.9825365
##  [130,] 1.1219915 1.8280818
##  [131,] 0.9544813 0.9625641
##  [132,] 0.8025150 1.3309963
##  [133,] 1.6289474 0.7243688
##  [134,] 1.0397905 0.4758541
##  [135,] 0.8820570 0.4822910
##  [136,] 1.0662011 1.0203328
##  [137,] 1.1719070 0.7635808
##  [138,] 1.1261014 1.2676171
##  [139,] 0.6267260 1.2767530
##  [140,] 0.9526283 1.0677097
##  [141,] 0.7867381 0.3851933
##  [142,] 0.7121735 0.9713162
##  [143,] 0.7718957 1.3472473
##  [144,] 0.8054158 0.5003529
##  [145,] 0.7794721 0.7369677
##  [146,] 1.0471820 0.9943166
##  [147,] 0.5537306 0.6284946
##  [148,] 1.0984754 0.5433515
##  [149,] 0.7076443 0.7362011
##  [150,] 0.7560671 0.9734971
##  [151,] 0.5188447 0.6303153
##  [152,] 0.9373959 0.5440518
##  [153,] 0.6840400 0.6292003
##  [154,] 1.0164252 0.4431677
##  [155,] 1.2390043 1.8548139
##  [156,] 0.7700961 1.0006283
##  [157,] 1.6147686 0.3701340
##  [158,] 0.9303391 0.8065100
##  [159,] 1.0856235 1.1199054
##  [160,] 0.8289836 1.0474860
##  [161,] 1.1076825 0.7995014
##  [162,] 0.9394082 1.2017600
##  [163,] 0.6242671 0.5779766
##  [164,] 1.2724582 1.0251069
##  [165,] 0.8015419 0.9180091
##  [166,] 0.6280421 1.8157524
##  [167,] 0.6664161 0.4150001
##  [168,] 0.5405783 1.4100008
##  [169,] 1.9187124 0.6119683
##  [170,] 1.0273508 1.2231622
##  [171,] 0.9928339 0.5765058
##  [172,] 1.0180226 1.3443438
##  [173,] 1.0008177 0.8015303
##  [174,] 1.3308882 0.5235442
##  [175,] 0.8595496 1.5665457
##  [176,] 1.2071544 0.4483895
##  [177,] 0.7149690 0.6574434
##  [178,] 0.9559583 0.6666525
##  [179,] 0.6556762 0.9064583
##  [180,] 0.9606622 1.2839579
##  [181,] 1.4717642 1.1553159
##  [182,] 0.7950858 0.5929231
##  [183,] 0.7755726 0.8175960
##  [184,] 0.7441198 0.5377206
##  [185,] 1.0308417 1.2407305
##  [186,] 1.0069006 0.7128618
##  [187,] 1.2212691 0.2796199
##  [188,] 0.8214166 0.4755098
##  [189,] 0.6782254 1.2229798
##  [190,] 0.7697660 0.7279078
##  [191,] 0.7937778 0.7955345
##  [192,] 0.7361383 0.9856561
##  [193,] 1.5087533 1.2282996
##  [194,] 1.3342843 1.3334395
##  [195,] 0.8874250 0.6469953
##  [196,] 1.3485781 0.6647304
##  [197,] 0.9618792 1.3045683
##  [198,] 1.1519840 1.0603060
##  [199,] 0.8578777 1.4013389
##  [200,] 0.7755073 0.5423784
##  [201,] 1.9962043 1.0942147
##  [202,] 1.3715423 0.7125459
##  [203,] 1.1232056 0.9495855
##  [204,] 0.7226101 0.5729016
##  [205,] 1.3459042 1.1932812
##  [206,] 1.0751205 1.3952772
##  [207,] 0.9288233 0.7558349
##  [208,] 1.2613682 0.9381116
##  [209,] 0.7083816 0.4171575
##  [210,] 1.2078416 3.1501685
##  [211,] 1.1900442 1.5931843
##  [212,] 0.9057819 0.7898811
##  [213,] 0.7282663 1.9050476
##  [214,] 1.4051952 0.8067692
##  [215,] 1.3080414 3.2854532
##  [216,] 1.0733672 0.7420191
##  [217,] 1.0604532 0.6454203
##  [218,] 1.2214725 0.6737025
##  [219,] 0.9380437 0.7643380
##  [220,] 0.7923639 0.9740887
##  [221,] 1.3830100 0.6601004
##  [222,] 1.9312263 1.0028962
##  [223,] 0.9667683 0.7400515
##  [224,] 0.6243296 0.7782490
##  [225,] 0.8862323 0.6823899
##  [226,] 1.0816307 0.6977915
##  [227,] 1.4305316 0.9007096
##  [228,] 0.8889015 1.4206745
##  [229,] 1.1221802 1.1241354
##  [230,] 1.3248609 2.4086437
##  [231,] 0.9349991 0.5339280
##  [232,] 0.7368024 1.5722760
##  [233,] 1.1080232 0.4507864
##  [234,] 1.5878461 1.5121326
##  [235,] 1.0121215 1.0347524
##  [236,] 1.0905715 0.6015637
##  [237,] 0.9190194 1.0668067
##  [238,] 1.1180863 1.3794758
##  [239,] 1.3564543 1.2311368
##  [240,] 1.1054470 0.7799781
##  [241,] 1.2048500 1.6224338
##  [242,] 1.2994419 0.6541857
##  [243,] 1.0835931 1.4634184
##  [244,] 1.2154241 0.7422521
##  [245,] 0.8397514 1.1388209
##  [246,] 0.7318999 0.9844293
##  [247,] 0.8933531 0.4529078
##  [248,] 1.5241908 1.3016863
##  [249,] 1.2476573 0.7092460
##  [250,] 0.5308821 0.9083868
##  [251,] 1.2075562 0.5092369
##  [252,] 0.8639061 1.8821405
##  [253,] 0.9189782 1.5050550
##  [254,] 1.2150466 0.7964903
##  [255,] 1.4077898 0.5584026
##  [256,] 1.1833381 1.4770774
##  [257,] 0.7824850 2.9044537
##  [258,] 0.7373918 1.4061062
##  [259,] 0.8492069 1.2060709
##  [260,] 0.8654447 0.5681350
##  [261,] 0.8069060 1.2488323
##  [262,] 0.9933007 1.2715084
##  [263,] 0.9546977 0.7349406
##  [264,] 0.7704054 1.0004227
##  [265,] 1.2464634 0.4361440
##  [266,] 1.5653664 0.4049320
##  [267,] 0.6562030 0.6886004
##  [268,] 0.8504491 0.8109536
##  [269,] 0.6466085 1.6951022
##  [270,] 1.4055917 1.0524019
##  [271,] 1.1289856 0.2925188
##  [272,] 1.2138498 0.6282415
##  [273,] 1.0248491 1.6586194
##  [274,] 0.8746377 0.9975443
##  [275,] 1.2532399 1.9554849
##  [276,] 0.7524401 0.6360706
##  [277,] 0.9625736 0.8129975
##  [278,] 1.4995835 0.5437051
##  [279,] 1.4696024 0.7365886
##  [280,] 1.2784581 1.0100353
##  [281,] 1.0061795 1.2879904
##  [282,] 0.7721626 0.6759913
##  [283,] 1.0237424 0.6451097
##  [284,] 0.7846016 1.1516365
##  [285,] 0.9312600 1.0565050
##  [286,] 1.2860220 1.2708465
##  [287,] 0.8005899 2.8939600
##  [288,] 0.7539829 0.9838340
##  [289,] 0.6938872 0.4951531
##  [290,] 0.9698585 0.6294548
##  [291,] 1.2429711 1.0160577
##  [292,] 0.9510805 1.1118231
##  [293,] 0.7451050 0.7165809
##  [294,] 1.3949786 1.2467185
##  [295,] 0.7629868 1.7171424
##  [296,] 0.8872388 1.4598273
##  [297,] 0.6125939 0.9569268
##  [298,] 1.0068115 0.4159831
##  [299,] 1.1822366 0.6265698
##  [300,] 0.9066430 0.3635538
##  [301,] 0.6781939 1.4628442
##  [302,] 0.7304508 0.7848899
##  [303,] 0.6768430 0.7607763
##  [304,] 0.8609355 1.6512749
##  [305,] 0.7393033 0.9665607
##  [306,] 0.8735487 0.8545736
##  [307,] 0.8265115 2.4884699
##  [308,] 1.0242478 0.5600096
##  [309,] 0.8919252 1.0226355
##  [310,] 0.8353546 1.2417288
##  [311,] 0.7182199 0.9137420
##  [312,] 0.5587052 0.6441214
##  [313,] 0.9091923 1.3660089
##  [314,] 0.8541796 0.6620386
##  [315,] 1.6564720 1.2939430
##  [316,] 1.5748783 0.3050874
##  [317,] 0.8409294 0.8600855
##  [318,] 1.4883911 0.7425391
##  [319,] 0.8139092 1.1860264
##  [320,] 2.1780853 0.9123423
##  [321,] 0.6392611 0.5940971
##  [322,] 1.2885363 0.4410495
##  [323,] 1.0304484 1.6400981
##  [324,] 1.0590549 0.6890288
##  [325,] 1.2434646 1.7436328
##  [326,] 0.8574018 1.2513954
##  [327,] 1.5926453 0.9263940
##  [328,] 0.7450378 0.8649612
##  [329,] 0.8713451 0.7200279
##  [330,] 0.9617034 0.7617765
##  [331,] 1.3256090 0.9402983
##  [332,] 1.0187159 0.9695664
##  [333,] 1.0554899 0.6815827
##  [334,] 0.9029258 0.4790105
##  [335,] 1.0871021 1.2161743
##  [336,] 1.0454967 1.0912564
##  [337,] 0.8210677 1.3516464
##  [338,] 1.2144103 0.8600545
##  [339,] 0.9358917 1.1450151
##  [340,] 0.8715970 1.1176173
##  [341,] 0.8967879 0.9946662
##  [342,] 1.0793009 0.7332175
##  [343,] 1.0076579 0.5298233
##  [344,] 1.1068250 2.3031759
##  [345,] 0.8942692 0.8536939
##  [346,] 1.0647488 1.1638828
##  [347,] 1.4082871 1.4119068
##  [348,] 0.9290368 1.9591912
##  [349,] 1.1346900 1.0566055
##  [350,] 1.0203961 0.3272849
##  [351,] 0.9548169 0.4214984
##  [352,] 0.6421056 1.0658405
##  [353,] 1.0455758 1.6668561
##  [354,] 0.6825771 0.8974357
##  [355,] 0.8425457 0.6630386
##  [356,] 0.9764779 3.5217588
##  [357,] 1.1194236 1.0413438
##  [358,] 0.9254889 1.4422996
##  [359,] 1.1951482 1.5192385
##  [360,] 0.8602139 1.6416788
##  [361,] 0.7745220 1.2113134
##  [362,] 0.8512069 1.8300518
##  [363,] 0.9350747 1.8263714
##  [364,] 1.3558058 0.8433395
##  [365,] 1.6289176 1.0362344
##  [366,] 1.2594766 0.9382059
##  [367,] 0.7580750 1.0568504
##  [368,] 1.1973510 1.1284148
##  [369,] 0.7665558 0.7352766
##  [370,] 1.4038593 0.4959634
##  [371,] 0.7531209 0.9407849
##  [372,] 1.4536159 1.2496651
##  [373,] 1.4178051 1.9315193
##  [374,] 1.3015754 0.9279511
##  [375,] 0.9679119 1.5314897
##  [376,] 0.7340009 0.8538164
##  [377,] 0.8459029 0.4424432
##  [378,] 1.5109955 2.4213198
##  [379,] 0.9426671 0.4585830
##  [380,] 0.9452371 0.8522603
##  [381,] 0.9830111 1.6995681
##  [382,] 1.0437176 0.9450050
##  [383,] 0.6062387 0.7546881
##  [384,] 1.5474930 0.9874275
##  [385,] 0.9952468 1.5475512
##  [386,] 1.0855831 1.3109887
##  [387,] 1.0636337 1.1069421
##  [388,] 0.8510403 1.2512622
##  [389,] 1.4130586 0.9860710
##  [390,] 0.7927761 1.0583730
##  [391,] 0.7804556 1.1686166
##  [392,] 0.9391933 0.9113221
##  [393,] 0.6841771 1.2071231
##  [394,] 1.2557647 1.0608481
##  [395,] 0.7045976 0.7499721
##  [396,] 1.1108770 1.5333902
##  [397,] 1.0518381 1.2564925
##  [398,] 0.7055821 0.7198247
##  [399,] 0.8027458 1.8822155
##  [400,] 1.2481996 0.4647418
##  [401,] 0.9539152 0.8194070
##  [402,] 1.0457703 0.7018431
##  [403,] 1.4113047 1.2745680
##  [404,] 0.9928672 2.1307410
##  [405,] 0.8980481 0.7078859
##  [406,] 1.0822360 0.7379415
##  [407,] 1.2768407 0.9374404
##  [408,] 1.2423680 0.8325560
##  [409,] 0.6975107 0.6318438
##  [410,] 1.0885299 0.7741603
##  [411,] 0.7658967 1.3228597
##  [412,] 0.8187565 0.9816322
##  [413,] 0.6438458 0.4143051
##  [414,] 0.7451400 0.6043249
##  [415,] 1.0180582 0.3254651
##  [416,] 0.7673917 0.6976325
##  [417,] 0.8490926 0.6627059
##  [418,] 1.1569998 1.4516344
##  [419,] 1.1295361 0.5879329
##  [420,] 0.8365816 0.6016656
##  [421,] 0.7239907 0.4154519
##  [422,] 1.4762880 0.3491461
##  [423,] 0.7625623 1.4967536
##  [424,] 1.4787331 0.6061688
##  [425,] 1.2771292 0.8861754
##  [426,] 0.6968253 1.1565988
##  [427,] 1.0714561 0.7022718
##  [428,] 0.9250938 0.7653169
##  [429,] 1.5102514 1.2092139
##  [430,] 0.9781046 0.5170152
##  [431,] 0.7625180 1.2130891
##  [432,] 1.1197241 1.2973548
##  [433,] 1.0605849 0.6892730
##  [434,] 1.2526091 1.1260565
##  [435,] 0.8992341 0.6498774
##  [436,] 1.2855238 0.7213123
##  [437,] 0.9970956 0.8314396
##  [438,] 1.0417177 1.2629498
##  [439,] 1.1086362 0.2264536
##  [440,] 1.1914675 0.6930685
##  [441,] 0.8871695 0.4313049
##  [442,] 0.7227966 1.0482167
##  [443,] 1.2682788 1.1372788
##  [444,] 0.6139430 0.4905180
##  [445,] 0.8136089 0.4034183
##  [446,] 1.0489867 0.7023568
##  [447,] 0.8334245 0.5630654
##  [448,] 0.8525345 0.6035779
##  [449,] 1.3778159 1.1990042
##  [450,] 0.9643297 0.5914386
##  [451,] 0.6861480 1.9448390
##  [452,] 0.7924603 0.6651042
##  [453,] 0.9824110 1.0306132
##  [454,] 1.1627961 0.8457280
##  [455,] 1.2116014 0.8706596
##  [456,] 1.0226221 1.1961007
##  [457,] 1.2205793 0.6283819
##  [458,] 0.9192785 0.6475148
##  [459,] 1.2754056 0.9171289
##  [460,] 1.2807618 1.5893232
##  [461,] 0.9187052 0.5704187
##  [462,] 1.2692028 1.2350762
##  [463,] 1.3955537 0.9214734
##  [464,] 0.9674832 0.6243263
##  [465,] 0.9854467 1.3177043
##  [466,] 1.0645761 0.7178588
##  [467,] 1.5312320 0.5531386
##  [468,] 0.8304588 0.5353913
##  [469,] 0.6525331 0.7180254
##  [470,] 1.1242355 0.6191113
##  [471,] 1.4447947 1.1829041
##  [472,] 1.6740663 0.8821981
##  [473,] 1.0466862 0.9260688
##  [474,] 0.7264624 0.6331580
##  [475,] 1.1014775 0.7979482
##  [476,] 1.2536773 0.6051721
##  [477,] 0.9482256 0.7823559
##  [478,] 1.2629359 0.7897152
##  [479,] 0.9778562 1.8112591
##  [480,] 0.8775214 1.5565040
##  [481,] 1.4963690 0.7626876
##  [482,] 0.8727328 1.4875974
##  [483,] 0.8419047 1.4382479
##  [484,] 0.5072685 0.8521052
##  [485,] 0.8972403 0.7800916
##  [486,] 1.0307260 1.5664110
##  [487,] 0.9941398 0.5490776
##  [488,] 0.9766357 0.8953110
##  [489,] 0.8473583 0.8031359
##  [490,] 0.8399482 1.8866733
##  [491,] 1.4919672 1.6875744
##  [492,] 0.8583269 1.4163803
##  [493,] 1.1168341 2.4030233
##  [494,] 0.6865821 0.4289993
##  [495,] 1.4550474 1.8112153
##  [496,] 1.1723616 1.2124864
##  [497,] 1.4820004 1.1594391
##  [498,] 1.4690661 0.7774867
##  [499,] 0.9836796 0.6179477
##  [500,] 0.7469482 0.8823262
##  [501,] 0.8710359 1.0097605
##  [502,] 0.6978874 0.9075847
##  [503,] 1.0524759 0.7905578
##  [504,] 1.0621739 0.3118972
##  [505,] 0.8046171 0.5348923
##  [506,] 0.7409214 1.3899857
##  [507,] 0.6971297 0.9062767
##  [508,] 0.8146807 0.6844804
##  [509,] 0.8132085 1.8734356
##  [510,] 0.6436499 0.7734741
##  [511,] 1.4189640 0.3743442
##  [512,] 0.9556521 1.2184904
##  [513,] 1.1875814 2.7710690
##  [514,] 0.8562293 1.0444030
##  [515,] 1.1073438 1.2476662
##  [516,] 0.9526306 1.5913952
##  [517,] 0.7161789 1.1168487
##  [518,] 1.8876818 1.1330511
##  [519,] 1.1155289 1.1328739
##  [520,] 1.0324715 1.3711075
##  [521,] 1.0438349 0.4497342
##  [522,] 0.7556056 1.2047255
##  [523,] 0.9215042 1.4078556
##  [524,] 1.0182872 0.8219932
##  [525,] 1.3821440 1.1789640
##  [526,] 0.9462869 0.7641474
##  [527,] 0.7128921 0.4556033
##  [528,] 0.6854579 1.1682135
##  [529,] 0.8430753 0.9274703
##  [530,] 0.8358102 0.9891979
##  [531,] 0.7915413 0.3545855
##  [532,] 0.8838607 1.1628205
##  [533,] 0.8638890 0.4911873
##  [534,] 0.9882737 0.9057814
##  [535,] 0.9718448 3.1373758
##  [536,] 0.9239785 0.9212948
##  [537,] 1.7449535 1.5013204
##  [538,] 0.8647674 0.6767976
##  [539,] 1.2508070 0.2356100
##  [540,] 0.8527770 0.6268322
##  [541,] 0.9144195 0.8287361
##  [542,] 1.2217298 1.4006218
##  [543,] 1.1407400 2.6020916
##  [544,] 1.0333544 0.9152451
##  [545,] 1.2617321 0.8114005
##  [546,] 0.9934762 0.4854354
##  [547,] 0.7802307 0.7504229
##  [548,] 0.7050897 0.8174537
##  [549,] 0.9547532 1.3498389
##  [550,] 0.9037425 0.7274444
##  [551,] 0.8255921 0.6031908
##  [552,] 1.3092293 1.1786095
##  [553,] 0.9139354 1.2353342
##  [554,] 0.9884562 1.3475361
##  [555,] 1.1415174 1.1903517
##  [556,] 0.9284047 1.1471572
##  [557,] 0.8775272 1.1948849
##  [558,] 1.0310938 0.8501855
##  [559,] 1.1898677 0.7068837
##  [560,] 0.8364823 1.0099707
##  [561,] 0.9759784 2.2204311
##  [562,] 0.6458398 0.9778845
##  [563,] 1.1297828 1.6527389
##  [564,] 1.1037274 0.5690204
##  [565,] 1.0195232 1.0164947
##  [566,] 1.6157872 0.5169248
##  [567,] 1.3398200 0.4421159
##  [568,] 0.6867755 1.1361474
##  [569,] 1.4263308 0.4908120
##  [570,] 0.6012687 1.0134615
##  [571,] 0.8558992 0.7702419
##  [572,] 0.7698514 0.7288964
##  [573,] 0.8111213 1.1530292
##  [574,] 1.2577162 0.6487263
##  [575,] 0.8935926 1.0307683
##  [576,] 0.7779443 0.8202667
##  [577,] 0.8917907 1.0600195
##  [578,] 0.8982975 0.7726187
##  [579,] 1.2806137 0.5048358
##  [580,] 1.1802490 0.9547371
##  [581,] 1.4998659 0.6949109
##  [582,] 1.0996669 1.1336984
##  [583,] 0.8307690 1.1808028
##  [584,] 1.2245755 0.8102214
##  [585,] 1.2709666 0.4750038
##  [586,] 0.5314560 1.0797646
##  [587,] 0.8711323 0.9471940
##  [588,] 0.8153820 1.1216046
##  [589,] 0.9170530 0.5711473
##  [590,] 1.1416811 0.6123926
##  [591,] 0.9818796 0.9341300
##  [592,] 1.0898569 1.8640957
##  [593,] 0.5967401 0.3102678
##  [594,] 0.7867235 1.6193214
##  [595,] 1.0077546 0.8014695
##  [596,] 0.8676833 0.9928142
##  [597,] 0.7646967 0.5029087
##  [598,] 0.8066934 0.5720550
##  [599,] 0.8835717 0.9083063
##  [600,] 0.8667133 0.8690051
##  [601,] 1.2799598 0.9552776
##  [602,] 0.7610514 0.8376806
##  [603,] 0.9397210 0.6627045
##  [604,] 1.1773477 0.8468087
##  [605,] 1.3083762 0.6650430
##  [606,] 0.8028407 1.3722677
##  [607,] 1.9568337 0.7079585
##  [608,] 0.8215022 0.9645899
##  [609,] 0.9979710 0.6746427
##  [610,] 0.8391955 0.7788678
##  [611,] 1.0175294 0.3654176
##  [612,] 1.3105094 1.1363512
##  [613,] 0.7460614 0.4290420
##  [614,] 2.0614116 0.7730349
##  [615,] 0.7353564 0.7055130
##  [616,] 0.9424891 0.6276877
##  [617,] 0.9087396 0.8759644
##  [618,] 0.7122016 0.8220749
##  [619,] 1.2008692 1.2764034
##  [620,] 0.6337281 0.4128868
##  [621,] 0.9499206 0.7451377
##  [622,] 0.6260845 0.6578418
##  [623,] 0.9382678 0.7553303
##  [624,] 1.6506719 0.5702789
##  [625,] 1.0330953 0.9672206
##  [626,] 0.8542945 0.4903486
##  [627,] 1.1013488 0.9325608
##  [628,] 0.7169910 0.7142613
##  [629,] 1.1562875 0.5515157
##  [630,] 1.0449852 0.6524855
##  [631,] 0.6958363 0.7095909
##  [632,] 1.0311804 0.8213834
##  [633,] 1.0549399 1.3497597
##  [634,] 0.6086714 1.0298242
##  [635,] 1.5083589 0.7707665
##  [636,] 1.4887646 1.6293578
##  [637,] 1.5582767 1.5348018
##  [638,] 0.7784768 0.7788858
##  [639,] 0.5706502 1.2307140
##  [640,] 0.7505233 0.9447189
##  [641,] 1.5673960 2.1228075
##  [642,] 1.1876050 0.6734627
##  [643,] 0.8404080 0.5471004
##  [644,] 0.8405483 0.8673566
##  [645,] 1.0456342 1.3923033
##  [646,] 1.4604192 1.4743981
##  [647,] 0.9775550 0.7396153
##  [648,] 1.4942590 0.7935173
##  [649,] 0.9527862 1.1243114
##  [650,] 0.8949265 0.5281606
##  [651,] 0.9021570 0.9788047
##  [652,] 0.9596371 1.7707304
##  [653,] 0.9894395 0.9458421
##  [654,] 1.8134275 0.3600076
##  [655,] 0.9835931 0.7253674
##  [656,] 1.0994949 1.2484741
##  [657,] 0.7067427 0.8932550
##  [658,] 1.5293800 0.6409716
##  [659,] 0.8648560 0.5067119
##  [660,] 1.0208677 0.7647610
##  [661,] 1.1321740 0.8625045
##  [662,] 0.7891475 0.9299483
##  [663,] 0.7960456 0.8288751
##  [664,] 0.6038503 1.0272583
##  [665,] 0.8448241 1.1683750
##  [666,] 1.2462859 0.4268149
##  [667,] 1.1993513 1.8279801
##  [668,] 1.5356875 0.7199754
##  [669,] 1.1041121 0.5502263
##  [670,] 0.8838197 0.7101505
##  [671,] 1.3485547 1.7317043
##  [672,] 1.3156648 0.7389495
##  [673,] 0.6695419 1.3132687
##  [674,] 1.0010391 0.4816992
##  [675,] 1.4423265 0.7431355
##  [676,] 0.8219334 0.6232921
##  [677,] 0.6544428 0.5864426
##  [678,] 1.0469058 0.9366966
##  [679,] 1.2894070 0.9084973
##  [680,] 0.6694479 0.9100826
##  [681,] 1.4041876 0.5928367
##  [682,] 0.9821440 1.6773474
##  [683,] 1.0333485 1.0725774
##  [684,] 0.9163697 1.5857224
##  [685,] 1.4745550 0.5066116
##  [686,] 1.1020829 0.5991136
##  [687,] 0.6479417 1.1663722
##  [688,] 0.8839426 0.5841166
##  [689,] 1.1777775 0.5484109
##  [690,] 1.2087005 0.5373440
##  [691,] 1.2407286 0.8662645
##  [692,] 0.6841181 0.2649540
##  [693,] 1.1590287 1.3262983
##  [694,] 1.0396256 0.8226584
##  [695,] 0.6399013 1.5366669
##  [696,] 0.8768708 0.7846731
##  [697,] 1.1978634 0.6100193
##  [698,] 0.9578426 1.2688122
##  [699,] 0.9408152 0.8178487
##  [700,] 1.0524895 1.8780732
##  [701,] 1.1450757 0.7208131
##  [702,] 0.7647032 0.4828538
##  [703,] 1.1024414 0.9056811
##  [704,] 0.7676395 0.8420203
##  [705,] 1.0295557 1.5253242
##  [706,] 1.1075471 3.5718333
##  [707,] 1.8698621 0.9354640
##  [708,] 0.9162327 0.5037171
##  [709,] 0.7267737 0.8043288
##  [710,] 1.2730165 0.9206520
##  [711,] 0.9709511 1.1348800
##  [712,] 1.5689174 0.3988106
##  [713,] 1.3338358 1.5992401
##  [714,] 0.7718930 1.0117852
##  [715,] 0.6621083 1.5525954
##  [716,] 0.6126165 0.6814614
##  [717,] 0.8255610 2.5585547
##  [718,] 1.0326522 0.9164155
##  [719,] 0.6881420 0.6093092
##  [720,] 1.3516501 1.0788624
##  [721,] 1.1660606 1.6267313
##  [722,] 1.0304649 0.6655455
##  [723,] 0.8227835 1.4695040
##  [724,] 1.3003917 0.9563256
##  [725,] 0.6719221 1.4040941
##  [726,] 1.0754983 1.4373209
##  [727,] 1.2247113 1.5969685
##  [728,] 1.3659253 0.4840975
##  [729,] 0.9646813 0.7833402
##  [730,] 1.1535512 0.7514091
##  [731,] 0.9509778 2.5347726
##  [732,] 0.9474596 1.2481410
##  [733,] 0.9936180 1.1999198
##  [734,] 0.8064028 0.4260283
##  [735,] 1.1295741 1.0178881
##  [736,] 1.5487217 0.6019171
##  [737,] 1.1848155 0.9327172
##  [738,] 1.0287171 1.0430385
##  [739,] 0.8594104 0.4776941
##  [740,] 0.9676694 0.5174167
##  [741,] 1.5095600 1.3300583
##  [742,] 1.7904268 0.9975508
##  [743,] 1.2499419 1.7710033
##  [744,] 1.2216913 1.3379680
##  [745,] 1.4200010 1.5895607
##  [746,] 0.8560033 0.9860736
##  [747,] 0.8333466 0.7918813
##  [748,] 1.0133929 1.5905233
##  [749,] 0.8446673 0.8039282
##  [750,] 0.7925799 1.0222584
##  [751,] 1.1404566 1.3151896
##  [752,] 0.8642169 1.1870183
##  [753,] 0.6371856 1.6763560
##  [754,] 1.0399450 1.2324850
##  [755,] 0.8401377 0.6685681
##  [756,] 1.1136593 1.0152332
##  [757,] 0.6956941 1.5804716
##  [758,] 0.8689610 0.9601695
##  [759,] 0.6809525 0.8265949
##  [760,] 1.5923405 0.8082599
##  [761,] 0.5225151 1.0357296
##  [762,] 0.8190181 1.5363568
##  [763,] 0.8433551 0.7459209
##  [764,] 1.0102829 1.8431915
##  [765,] 0.9333361 0.4420044
##  [766,] 0.9214095 1.3136919
##  [767,] 0.9477960 0.6767532
##  [768,] 1.6750686 0.5248930
##  [769,] 0.9540671 0.6698457
##  [770,] 0.6940329 1.1237045
##  [771,] 0.8943033 0.8304546
##  [772,] 1.0429675 0.8479666
##  [773,] 0.6753567 0.9667529
##  [774,] 1.5488000 0.9101489
##  [775,] 1.4963616 0.5609611
##  [776,] 1.3116327 0.3969889
##  [777,] 0.8508755 1.3874896
##  [778,] 1.2901100 0.4476378
##  [779,] 1.1325694 0.5948203
##  [780,] 0.7753648 0.6837279
##  [781,] 0.6331840 0.6880943
##  [782,] 1.1362305 0.9916112
##  [783,] 0.9311583 1.3467915
##  [784,] 1.2225192 0.6446461
##  [785,] 1.3223936 0.6381489
##  [786,] 1.5082156 1.0051237
##  [787,] 1.1494998 1.0643602
##  [788,] 1.0875954 0.4382086
##  [789,] 0.9100576 1.1309691
##  [790,] 0.9399228 1.4551910
##  [791,] 0.7558758 1.3167459
##  [792,] 1.4435548 1.0402769
##  [793,] 0.6182999 0.8048617
##  [794,] 1.2171838 1.3314962
##  [795,] 0.7191092 1.1296915
##  [796,] 1.0856514 0.9274554
##  [797,] 1.0658759 0.6783872
##  [798,] 0.9135986 1.0826737
##  [799,] 0.8942132 0.2886000
##  [800,] 0.8863448 0.5861358
##  [801,] 0.8520260 0.8810282
##  [802,] 1.0378177 1.4647251
##  [803,] 0.9730649 0.5793979
##  [804,] 0.6967023 0.6235000
##  [805,] 0.7807464 2.0732992
##  [806,] 1.5953955 0.9074254
##  [807,] 1.2616932 1.0124757
##  [808,] 1.0115558 0.9392386
##  [809,] 1.3718165 0.6470189
##  [810,] 1.5988665 1.7055638
##  [811,] 1.0658805 0.5704390
##  [812,] 0.8400038 0.9282531
##  [813,] 1.5134123 0.7191480
##  [814,] 0.9668928 0.5601702
##  [815,] 1.1137235 1.3947784
##  [816,] 0.7132268 1.5488168
##  [817,] 1.1337042 1.8981076
##  [818,] 1.1073323 1.0340899
##  [819,] 0.6639977 1.6449177
##  [820,] 0.8597833 1.0862305
##  [821,] 1.0767259 0.6000929
##  [822,] 1.1686302 0.8692098
##  [823,] 0.7564342 1.4081236
##  [824,] 1.1473829 1.0583342
##  [825,] 1.1413866 0.3393139
##  [826,] 1.4050828 0.9695903
##  [827,] 0.8028489 0.7177223
##  [828,] 1.0024513 1.5171240
##  [829,] 1.0885357 2.2507194
##  [830,] 0.9735890 1.3293470
##  [831,] 1.3079677 0.8765424
##  [832,] 1.1134444 2.2726494
##  [833,] 1.4792388 0.8418026
##  [834,] 1.5895768 0.6855072
##  [835,] 1.2498300 1.2124306
##  [836,] 0.8839473 0.9639180
##  [837,] 0.8886753 0.7891993
##  [838,] 0.4431960 0.6701371
##  [839,] 1.1678967 1.2862950
##  [840,] 1.2193388 1.1372833
##  [841,] 1.0825351 0.6519614
##  [842,] 0.8155840 0.9861772
##  [843,] 0.9370756 0.6666593
##  [844,] 0.8665578 0.4995074
##  [845,] 1.0523410 1.1992610
##  [846,] 1.4888378 2.3164293
##  [847,] 1.9103020 1.1891211
##  [848,] 1.1214953 0.8704043
##  [849,] 1.1737195 0.4399073
##  [850,] 1.5503483 0.9590510
##  [851,] 0.8911230 0.9036479
##  [852,] 0.9448527 1.1325738
##  [853,] 0.5388717 1.1800437
##  [854,] 1.1254500 1.0695734
##  [855,] 1.5092803 0.5637921
##  [856,] 0.7727983 0.7287664
##  [857,] 0.8347588 2.0838472
##  [858,] 1.0737575 1.6819864
##  [859,] 0.9694650 1.1215847
##  [860,] 0.9009594 0.9787351
##  [861,] 1.2410295 1.0661092
##  [862,] 0.7755450 0.6398497
##  [863,] 1.0555369 1.9403698
##  [864,] 0.8617639 1.5059321
##  [865,] 1.0977302 0.6924714
##  [866,] 1.5568477 0.6589038
##  [867,] 0.8530957 1.0830582
##  [868,] 1.0136956 1.0862547
##  [869,] 1.0396463 0.5740579
##  [870,] 1.0524209 1.8582513
##  [871,] 0.9143362 0.9303552
##  [872,] 1.0348643 0.3711995
##  [873,] 0.8081799 1.0082224
##  [874,] 0.6998878 0.5769565
##  [875,] 1.0057199 0.8499647
##  [876,] 1.4107085 0.6860812
##  [877,] 0.8861360 1.0597761
##  [878,] 0.7586528 0.9452972
##  [879,] 0.8770250 0.4798368
##  [880,] 1.2831925 0.6573845
##  [881,] 0.7898019 1.6807617
##  [882,] 0.6222389 0.8525618
##  [883,] 1.0568672 0.5719510
##  [884,] 0.6128447 0.5211553
##  [885,] 1.1852566 0.8009612
##  [886,] 0.7494820 0.9079155
##  [887,] 2.2705730 0.6643926
##  [888,] 0.9387477 0.9307177
##  [889,] 1.1372956 1.2726768
##  [890,] 1.1056602 0.9408149
##  [891,] 1.3100462 0.7184166
##  [892,] 1.3640876 0.9237274
##  [893,] 1.8854094 0.9486118
##  [894,] 1.5623102 1.0392064
##  [895,] 1.0477882 0.7942683
##  [896,] 0.7025976 1.1561781
##  [897,] 0.7305998 1.0329560
##  [898,] 1.2521333 0.8801257
##  [899,] 0.7518455 1.3001124
##  [900,] 1.1931583 0.5904617
##  [901,] 1.1529028 0.9688946
##  [902,] 1.2339957 0.9073828
##  [903,] 1.0363692 3.5236210
##  [904,] 1.2710984 1.7880114
##  [905,] 0.7261584 0.7093032
##  [906,] 0.8613708 0.6742198
##  [907,] 1.4482536 0.5554376
##  [908,] 1.0424431 2.3369721
##  [909,] 0.9675584 0.8256149
##  [910,] 0.9513438 1.0663908
##  [911,] 1.1780973 2.5020727
##  [912,] 1.2410407 0.5829437
##  [913,] 1.2720331 1.1782256
##  [914,] 0.8778313 0.8967488
##  [915,] 0.7570986 0.6032258
##  [916,] 1.2987914 0.9878027
##  [917,] 0.8571188 0.5525037
##  [918,] 1.3717993 0.4480053
##  [919,] 1.1089257 0.4603817
##  [920,] 1.1218372 0.9982695
##  [921,] 0.6337817 1.6126160
##  [922,] 1.1637125 0.5660365
##  [923,] 0.8244192 1.1843923
##  [924,] 0.6348701 1.0363413
##  [925,] 0.9288011 0.5301548
##  [926,] 1.2457657 0.9506541
##  [927,] 1.0450209 0.8616797
##  [928,] 0.8388663 1.0789474
##  [929,] 0.9056775 0.8054165
##  [930,] 0.6306841 1.2855580
##  [931,] 0.7164210 0.7574309
##  [932,] 0.7490253 0.6828026
##  [933,] 0.8705613 0.2750257
##  [934,] 1.4360365 0.6336289
##  [935,] 1.1127703 0.8133213
##  [936,] 0.6889773 0.6429527
##  [937,] 1.0166759 0.8870287
##  [938,] 1.4372940 0.7673723
##  [939,] 1.0777079 1.0660925
##  [940,] 0.9400733 1.2414292
##  [941,] 1.1358122 1.4231808
##  [942,] 1.0315947 0.6118295
##  [943,] 1.2608258 0.4062071
##  [944,] 0.8789856 0.9117210
##  [945,] 0.8266152 0.9236075
##  [946,] 0.9086779 0.3827947
##  [947,] 1.3130550 1.3513921
##  [948,] 1.3181032 0.4915600
##  [949,] 0.9398726 1.3292796
##  [950,] 0.6125832 0.5705926
##  [951,] 1.2726218 1.2506352
##  [952,] 0.7928706 1.9553740
##  [953,] 0.6553986 0.3675460
##  [954,] 1.0787193 1.0380586
##  [955,] 0.7498167 0.9997647
##  [956,] 0.7572757 1.0946170
##  [957,] 0.8130899 0.8080455
##  [958,] 1.2574132 1.5132032
##  [959,] 1.1375626 0.7673036
##  [960,] 1.0858984 0.6724543
##  [961,] 0.7844195 1.9494578
##  [962,] 0.7303669 0.6055390
##  [963,] 0.9053209 1.3270966
##  [964,] 1.2011637 0.9521588
##  [965,] 1.2436333 2.1650655
##  [966,] 0.8059219 1.3660815
##  [967,] 1.0553739 0.4462890
##  [968,] 1.2062810 0.7991985
##  [969,] 1.2772886 1.2403437
##  [970,] 0.8358149 0.8865343
##  [971,] 1.3553327 1.6430848
##  [972,] 1.1994329 1.1673742
##  [973,] 0.6834712 1.5583371
##  [974,] 0.7036976 1.0793058
##  [975,] 0.9661767 0.2583828
##  [976,] 0.5827990 0.6249352
##  [977,] 1.0392617 0.4799931
##  [978,] 1.3647223 0.3303207
##  [979,] 1.4554755 1.1343119
##  [980,] 0.6128466 0.8838874
##  [981,] 1.0972723 0.4509722
##  [982,] 1.2653384 0.8642098
##  [983,] 0.7842580 0.7245485
##  [984,] 1.2868772 1.4744275
##  [985,] 0.6849563 0.6160927
##  [986,] 0.6969326 0.7701947
##  [987,] 0.6456265 1.4846652
##  [988,] 0.6517346 0.8484160
##  [989,] 0.7864285 1.4855160
##  [990,] 0.7457597 0.6813700
##  [991,] 0.9378587 1.2924194
##  [992,] 1.3856053 0.7972371
##  [993,] 0.7506426 0.6820742
##  [994,] 1.0215467 2.4622072
##  [995,] 1.2681921 1.1527228
##  [996,] 0.7311683 0.9250849
##  [997,] 0.9922332 0.6218878
##  [998,] 0.9335732 0.8474438
##  [999,] 1.1335163 0.9055260
## 
## $model.matrix
##     (Intercept) format_16S_L6_AA$Group11 format_16S_L6_AA$Group12
## 1             1                       -1                       -1
## 2             1                        1                        0
## 3             1                        0                        0
## 4             1                        0                        1
## 5             1                       -1                       -1
## 6             1                        1                        0
## 7             1                        0                        0
## 8             1                        0                        1
## 9             1                       -1                       -1
## 10            1                        1                        0
## 11            1                        0                        0
## 12            1                        0                        1
## 13            1                       -1                       -1
## 14            1                        1                        0
## 15            1                        0                        0
## 16            1                        0                        1
## 17            1                       -1                       -1
## 18            1                        1                        0
## 19            1                        0                        0
## 20            1                        0                        1
## 21            1                       -1                       -1
## 22            1                        1                        0
## 23            1                        0                        0
## 24            1                        0                        1
## 25            1                       -1                       -1
## 26            1                        1                        0
## 27            1                        0                        0
## 28            1                        0                        1
## 29            1                       -1                       -1
## 30            1                        1                        0
## 31            1                        0                        0
## 32            1                        0                        1
## 33            1                       -1                       -1
## 34            1                        1                        0
## 35            1                        0                        0
## 36            1                        0                        1
## 37            1                       -1                       -1
## 38            1                        1                        0
## 39            1                        0                        0
## 40            1                        0                        1
## 41            1                       -1                       -1
## 42            1                        1                        0
## 43            1                        0                        0
## 44            1                        0                        1
## 45            1                       -1                       -1
## 46            1                        1                        0
## 47            1                        0                        0
## 48            1                        0                        1
## 49            1                       -1                       -1
## 50            1                        1                        0
## 51            1                        0                        0
## 52            1                        0                        1
## 53            1                       -1                       -1
## 54            1                        1                        0
## 55            1                        0                        0
## 56            1                        0                        1
## 57            1                       -1                       -1
## 58            1                        1                        0
## 59            1                        0                        0
## 60            1                        0                        1
## 61            1                       -1                       -1
## 62            1                        1                        0
## 63            1                        0                        0
## 64            1                        0                        1
## 65            1                       -1                       -1
## 66            1                        1                        0
## 67            1                        0                        0
## 68            1                        0                        1
## 69            1                       -1                       -1
## 70            1                        1                        0
## 71            1                        0                        0
## 72            1                        0                        1
## 73            1                       -1                       -1
## 74            1                        1                        0
## 75            1                        0                        0
## 76            1                        0                        1
## 77            1                       -1                       -1
## 78            1                        1                        0
## 79            1                        0                        0
## 80            1                        0                        1
## 81            1                       -1                       -1
## 82            1                        1                        0
## 83            1                        0                        0
## 84            1                        0                        1
## 85            1                       -1                       -1
## 86            1                        1                        0
## 87            1                        0                        0
## 88            1                        0                        1
## 89            1                       -1                       -1
## 90            1                        1                        0
## 91            1                        0                        0
## 92            1                        0                        1
## 93            1                       -1                       -1
## 94            1                        1                        0
## 95            1                        0                        0
## 96            1                        0                        1
## 97            1                       -1                       -1
## 98            1                        1                        0
## 99            1                        0                        0
## 100           1                        0                        1
## 101           1                       -1                       -1
## 102           1                        1                        0
## 103           1                        0                        0
## 104           1                        0                        1
## 105           1                       -1                       -1
## 106           1                        1                        0
## 107           1                        0                        0
## 108           1                        0                        1
## 109           1                       -1                       -1
## 110           1                        1                        0
## 111           1                        0                        0
## 112           1                        0                        1
## 113           1                       -1                       -1
## 114           1                        1                        0
## 115           1                        0                        0
## 116           1                        0                        1
## 117           1                       -1                       -1
## 118           1                        1                        0
## 119           1                        0                        0
## 120           1                        0                        1
## 121           1                       -1                       -1
## 122           1                        1                        0
## 123           1                        0                        0
## 124           1                        0                        1
## 125           1                       -1                       -1
## 126           1                        1                        0
## 127           1                        0                        0
## 128           1                        0                        1
## 129           1                       -1                       -1
## 130           1                        1                        0
## 131           1                        0                        0
## 132           1                        0                        1
## 133           1                       -1                       -1
## 134           1                        1                        0
## 135           1                        0                        0
## 136           1                        0                        1
## 137           1                       -1                       -1
## 138           1                        1                        0
## 139           1                        0                        0
## 140           1                        0                        1
## 141           1                       -1                       -1
## 142           1                        1                        0
## 143           1                        0                        0
## 144           1                        0                        1
## 145           1                       -1                       -1
## 146           1                        1                        0
## 147           1                        0                        0
## 148           1                        0                        1
## 149           1                       -1                       -1
## 150           1                        1                        0
## 151           1                        0                        0
## 152           1                        0                        1
## 153           1                       -1                       -1
## 154           1                        1                        0
## 155           1                        0                        0
## 156           1                        0                        1
## 157           1                       -1                       -1
## 158           1                        1                        0
## 159           1                        0                        0
## 160           1                        0                        1
## 161           1                       -1                       -1
## 162           1                        1                        0
## 163           1                        0                        0
## 164           1                        0                        1
## 165           1                       -1                       -1
## 166           1                        1                        0
## 167           1                        0                        0
## 168           1                        0                        1
## 169           1                       -1                       -1
## 170           1                        1                        0
## 171           1                        0                        0
## 172           1                        0                        1
## 173           1                       -1                       -1
## 174           1                        1                        0
## 175           1                        0                        0
## 176           1                        0                        1
## 177           1                       -1                       -1
## 178           1                        1                        0
## 179           1                        0                        0
## 180           1                        0                        1
## 181           1                       -1                       -1
## 182           1                        1                        0
## 183           1                        0                        0
## 184           1                        0                        1
## 185           1                       -1                       -1
## 186           1                        1                        0
## 187           1                        0                        0
## 188           1                        0                        1
## 189           1                       -1                       -1
## 190           1                        1                        0
## 191           1                        0                        0
## 192           1                        0                        1
## 193           1                       -1                       -1
## 194           1                        1                        0
## 195           1                        0                        0
## 196           1                        0                        1
## 197           1                       -1                       -1
## 198           1                        1                        0
## 199           1                        0                        0
## 200           1                        0                        1
## 201           1                       -1                       -1
## 202           1                        1                        0
## 203           1                        0                        0
## 204           1                        0                        1
## 205           1                       -1                       -1
## 206           1                        1                        0
## 207           1                        0                        0
## 208           1                        0                        1
## 209           1                       -1                       -1
## 210           1                        1                        0
## 211           1                        0                        0
## 212           1                        0                        1
## 213           1                       -1                       -1
## 214           1                        1                        0
## 215           1                        0                        0
## 216           1                        0                        1
## 217           1                       -1                       -1
## 218           1                        1                        0
## 219           1                        0                        0
## 220           1                        0                        1
## 221           1                       -1                       -1
## 222           1                        1                        0
## 223           1                        0                        0
## 224           1                        0                        1
## 225           1                       -1                       -1
## 226           1                        1                        0
## 227           1                        0                        0
## 228           1                        0                        1
## 229           1                       -1                       -1
## 230           1                        1                        0
## 231           1                        0                        0
## 232           1                        0                        1
## 233           1                       -1                       -1
## 234           1                        1                        0
## 235           1                        0                        0
## 236           1                        0                        1
## 237           1                       -1                       -1
## 238           1                        1                        0
## 239           1                        0                        0
## 240           1                        0                        1
## 241           1                       -1                       -1
## 242           1                        1                        0
## 243           1                        0                        0
## 244           1                        0                        1
## 245           1                       -1                       -1
## 246           1                        1                        0
## 247           1                        0                        0
## 248           1                        0                        1
## 249           1                       -1                       -1
## 250           1                        1                        0
## 251           1                        0                        0
## 252           1                        0                        1
## 253           1                       -1                       -1
## 254           1                        1                        0
## 255           1                        0                        0
## 256           1                        0                        1
## 257           1                       -1                       -1
## 258           1                        1                        0
## 259           1                        0                        0
## 260           1                        0                        1
## 261           1                       -1                       -1
## 262           1                        1                        0
## 263           1                        0                        0
## 264           1                        0                        1
## 265           1                       -1                       -1
## 266           1                        1                        0
## 267           1                        0                        0
## 268           1                        0                        1
## 269           1                       -1                       -1
## 270           1                        1                        0
## 271           1                        0                        0
## 272           1                        0                        1
## 273           1                       -1                       -1
## 274           1                        1                        0
## 275           1                        0                        0
## 276           1                        0                        1
## 277           1                       -1                       -1
## 278           1                        1                        0
## 279           1                        0                        0
## 280           1                        0                        1
## 281           1                       -1                       -1
## 282           1                        1                        0
## 283           1                        0                        0
## 284           1                        0                        1
## 285           1                       -1                       -1
## 286           1                        1                        0
## 287           1                        0                        0
## 288           1                        0                        1
## 289           1                       -1                       -1
## 290           1                        1                        0
## 291           1                        0                        0
## 292           1                        0                        1
## 293           1                       -1                       -1
## 294           1                        1                        0
## 295           1                        0                        0
## 296           1                        0                        1
## 297           1                       -1                       -1
## 298           1                        1                        0
## 299           1                        0                        0
## 300           1                        0                        1
## 301           1                       -1                       -1
## 302           1                        1                        0
## 303           1                        0                        0
## 304           1                        0                        1
## 305           1                       -1                       -1
## 306           1                        1                        0
## 307           1                        0                        0
## 308           1                        0                        1
## 309           1                       -1                       -1
## 310           1                        1                        0
## 311           1                        0                        0
## 312           1                        0                        1
## 313           1                       -1                       -1
## 314           1                        1                        0
## 315           1                        0                        0
## 316           1                        0                        1
## 317           1                       -1                       -1
## 318           1                        1                        0
## 319           1                        0                        0
## 320           1                        0                        1
##     format_16S_L6_AA$Group13 dph
## 1                         -1   1
## 2                          0   1
## 3                          1   1
## 4                          0   1
## 5                         -1   1
## 6                          0   1
## 7                          1   1
## 8                          0   1
## 9                         -1   1
## 10                         0   1
## 11                         1   1
## 12                         0   1
## 13                        -1   1
## 14                         0   1
## 15                         1   1
## 16                         0   1
## 17                        -1   1
## 18                         0   1
## 19                         1   1
## 20                         0   1
## 21                        -1   1
## 22                         0   1
## 23                         1   1
## 24                         0   1
## 25                        -1   1
## 26                         0   1
## 27                         1   1
## 28                         0   1
## 29                        -1   1
## 30                         0   1
## 31                         1   1
## 32                         0   1
## 33                        -1   1
## 34                         0   1
## 35                         1   1
## 36                         0   1
## 37                        -1   1
## 38                         0   1
## 39                         1   1
## 40                         0   1
## 41                        -1   4
## 42                         0   4
## 43                         1   4
## 44                         0   4
## 45                        -1   4
## 46                         0   4
## 47                         1   4
## 48                         0   4
## 49                        -1   4
## 50                         0   4
## 51                         1   4
## 52                         0   4
## 53                        -1   4
## 54                         0   4
## 55                         1   4
## 56                         0   4
## 57                        -1   4
## 58                         0   4
## 59                         1   4
## 60                         0   4
## 61                        -1   4
## 62                         0   4
## 63                         1   4
## 64                         0   4
## 65                        -1   4
## 66                         0   4
## 67                         1   4
## 68                         0   4
## 69                        -1   4
## 70                         0   4
## 71                         1   4
## 72                         0   4
## 73                        -1   4
## 74                         0   4
## 75                         1   4
## 76                         0   4
## 77                        -1   4
## 78                         0   4
## 79                         1   4
## 80                         0   4
## 81                        -1   7
## 82                         0   7
## 83                         1   7
## 84                         0   7
## 85                        -1   7
## 86                         0   7
## 87                         1   7
## 88                         0   7
## 89                        -1   7
## 90                         0   7
## 91                         1   7
## 92                         0   7
## 93                        -1   7
## 94                         0   7
## 95                         1   7
## 96                         0   7
## 97                        -1   7
## 98                         0   7
## 99                         1   7
## 100                        0   7
## 101                       -1   7
## 102                        0   7
## 103                        1   7
## 104                        0   7
## 105                       -1   7
## 106                        0   7
## 107                        1   7
## 108                        0   7
## 109                       -1   7
## 110                        0   7
## 111                        1   7
## 112                        0   7
## 113                       -1   7
## 114                        0   7
## 115                        1   7
## 116                        0   7
## 117                       -1   7
## 118                        0   7
## 119                        1   7
## 120                        0   7
## 121                       -1  14
## 122                        0  14
## 123                        1  14
## 124                        0  14
## 125                       -1  14
## 126                        0  14
## 127                        1  14
## 128                        0  14
## 129                       -1  14
## 130                        0  14
## 131                        1  14
## 132                        0  14
## 133                       -1  14
## 134                        0  14
## 135                        1  14
## 136                        0  14
## 137                       -1  14
## 138                        0  14
## 139                        1  14
## 140                        0  14
## 141                       -1  14
## 142                        0  14
## 143                        1  14
## 144                        0  14
## 145                       -1  14
## 146                        0  14
## 147                        1  14
## 148                        0  14
## 149                       -1  14
## 150                        0  14
## 151                        1  14
## 152                        0  14
## 153                       -1  14
## 154                        0  14
## 155                        1  14
## 156                        0  14
## 157                       -1  14
## 158                        0  14
## 159                        1  14
## 160                        0  14
## 161                       -1  21
## 162                        0  21
## 163                        1  21
## 164                        0  21
## 165                       -1  21
## 166                        0  21
## 167                        1  21
## 168                        0  21
## 169                       -1  21
## 170                        0  21
## 171                        1  21
## 172                        0  21
## 173                       -1  21
## 174                        0  21
## 175                        1  21
## 176                        0  21
## 177                       -1  21
## 178                        0  21
## 179                        1  21
## 180                        0  21
## 181                       -1  21
## 182                        0  21
## 183                        1  21
## 184                        0  21
## 185                       -1  21
## 186                        0  21
## 187                        1  21
## 188                        0  21
## 189                       -1  21
## 190                        0  21
## 191                        1  21
## 192                        0  21
## 193                       -1  21
## 194                        0  21
## 195                        1  21
## 196                        0  21
## 197                       -1  21
## 198                        0  21
## 199                        1  21
## 200                        0  21
## 201                       -1  28
## 202                        0  28
## 203                        1  28
## 204                        0  28
## 205                       -1  28
## 206                        0  28
## 207                        1  28
## 208                        0  28
## 209                       -1  28
## 210                        0  28
## 211                        1  28
## 212                        0  28
## 213                       -1  28
## 214                        0  28
## 215                        1  28
## 216                        0  28
## 217                       -1  28
## 218                        0  28
## 219                        1  28
## 220                        0  28
## 221                       -1  28
## 222                        0  28
## 223                        1  28
## 224                        0  28
## 225                       -1  28
## 226                        0  28
## 227                        1  28
## 228                        0  28
## 229                       -1  28
## 230                        0  28
## 231                        1  28
## 232                        0  28
## 233                       -1  28
## 234                        0  28
## 235                        1  28
## 236                        0  28
## 237                       -1  28
## 238                        0  28
## 239                        1  28
## 240                        0  28
## 241                       -1  35
## 242                        0  35
## 243                        1  35
## 244                        0  35
## 245                       -1  35
## 246                        0  35
## 247                        1  35
## 248                        0  35
## 249                       -1  35
## 250                        0  35
## 251                        1  35
## 252                        0  35
## 253                       -1  35
## 254                        0  35
## 255                        1  35
## 256                        0  35
## 257                       -1  35
## 258                        0  35
## 259                        1  35
## 260                        0  35
## 261                       -1  35
## 262                        0  35
## 263                        1  35
## 264                        0  35
## 265                       -1  35
## 266                        0  35
## 267                        1  35
## 268                        0  35
## 269                       -1  35
## 270                        0  35
## 271                        1  35
## 272                        0  35
## 273                       -1  35
## 274                        0  35
## 275                        1  35
## 276                        0  35
## 277                       -1  35
## 278                        0  35
## 279                        1  35
## 280                        0  35
## 281                       -1  42
## 282                        0  42
## 283                        1  42
## 284                        0  42
## 285                       -1  42
## 286                        0  42
## 287                        1  42
## 288                        0  42
## 289                       -1  42
## 290                        0  42
## 291                        1  42
## 292                        0  42
## 293                       -1  42
## 294                        0  42
## 295                        1  42
## 296                        0  42
## 297                       -1  42
## 298                        0  42
## 299                        1  42
## 300                        0  42
## 301                       -1  42
## 302                        0  42
## 303                        1  42
## 304                        0  42
## 305                       -1  42
## 306                        0  42
## 307                        1  42
## 308                        0  42
## 309                       -1  42
## 310                        0  42
## 311                        1  42
## 312                        0  42
## 313                       -1  42
## 314                        0  42
## 315                        1  42
## 316                        0  42
## 317                       -1  42
## 318                        0  42
## 319                        1  42
## 320                        0  42
## 
## $terms
## format_16S_L6_AA[, 1:529] ~ format_16S_L6_AA$Group1 + dph
## attr(,"variables")
## list(format_16S_L6_AA[, 1:529], format_16S_L6_AA$Group1, dph)
## attr(,"factors")
##                           format_16S_L6_AA$Group1 dph
## format_16S_L6_AA[, 1:529]                       0   0
## format_16S_L6_AA$Group1                         1   0
## dph                                             0   1
## attr(,"term.labels")
## [1] "format_16S_L6_AA$Group1" "dph"                    
## attr(,"order")
## [1] 1 1
## attr(,"intercept")
## [1] 1
## attr(,"response")
## [1] 1
## attr(,".Environment")
## <environment: R_GlobalEnv>
## 
## attr(,"class")
## [1] "adonis"
set.seed(1234)
adonis(format_ITS_L6[,1:603] ~ format_ITS_L6$Group1 + dph)
## 'adonis' will be deprecated: use 'adonis2' instead
## $aov.tab
## Permutation: free
## Number of permutations: 999
## 
## Terms added sequentially (first to last)
## 
##                       Df SumsOfSqs MeanSqs F.Model      R2 Pr(>F)    
## format_ITS_L6$Group1   3    12.443  4.1477  25.298 0.18011  0.001 ***
## dph                    1     4.997  4.9974  30.481 0.07234  0.001 ***
## Residuals            315    51.645  0.1640         0.74755           
## Total                319    69.085                 1.00000           
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## $call
## adonis(formula = format_ITS_L6[, 1:603] ~ format_ITS_L6$Group1 + 
##     dph)
## 
## $coefficients
##                                 X__         X__.1      Diplodia Lasiodiplodia
## (Intercept)            0.0047213779  1.388333e-03  4.987206e-07  4.495495e-06
## format_ITS_L6$Group11 -0.0016416004 -8.463913e-04 -3.599856e-06 -1.678886e-06
## format_ITS_L6$Group12  0.0034351920  4.139659e-03 -3.599856e-06  3.978278e-06
## format_ITS_L6$Group13 -0.0028414512 -1.431949e-03 -3.599856e-06 -1.678886e-06
## dph                    0.0001316236  6.756038e-05  1.632177e-07 -1.482426e-07
##                        Macrophomina  unidentified         X__.2  Arthrocatena
## (Intercept)            2.880694e-05  4.917430e-07  2.335479e-03 -9.230203e-06
## format_ITS_L6$Group11 -1.057942e-05  1.410437e-05  1.058427e-03  2.392997e-05
## format_ITS_L6$Group12  3.173827e-05 -6.513314e-06 -7.249597e-04 -7.436888e-06
## format_ITS_L6$Group13 -1.057942e-05 -6.513314e-06 -2.866991e-04 -8.246541e-06
## dph                   -9.593431e-07  3.169248e-07 -1.395555e-05  9.198286e-07
##                        Cladosporium Rachicladosporium   Dissoconium
## (Intercept)            0.0292021439     -6.123918e-05  1.654809e-05
## format_ITS_L6$Group11  0.0171123773      8.310108e-05 -6.077327e-06
## format_ITS_L6$Group12 -0.0203986863      2.086905e-05  1.620513e-05
## format_ITS_L6$Group13  0.0013187723     -5.198507e-05 -4.050477e-06
## dph                    0.0002672701      5.959171e-06 -5.510926e-07
##                         Acrodontium    Cercospora      Septoria   Sphaerulina
## (Intercept)            7.121820e-07  1.245906e-04  1.365962e-05  1.210221e-05
## format_ITS_L6$Group11 -7.312967e-06 -9.997421e-05 -1.262746e-05 -4.444566e-06
## format_ITS_L6$Group12 -7.312967e-06  2.276950e-05 -5.534420e-06  3.085811e-06
## format_ITS_L6$Group13  1.996012e-05  5.288491e-05  2.260230e-05 -4.444566e-06
## dph                    3.474098e-07 -1.863848e-07 -5.432396e-08 -4.030337e-07
##                           Zasmidium  Recurvomyces unidentified.1 Aureobasidium
## (Intercept)           -3.044057e-06  5.956363e-06   5.953815e-05  1.255151e-03
## format_ITS_L6$Group11  1.056573e-05  1.283952e-05   4.866561e-05 -1.423038e-03
## format_ITS_L6$Group12 -4.655571e-06 -7.521276e-06  -2.408477e-05  3.878271e-03
## format_ITS_L6$Group13 -1.254592e-06 -6.840983e-06  -2.408477e-05 -1.053854e-03
## dph                    4.052435e-07  8.236384e-08  -1.865967e-06  6.107394e-05
##                           Coniozyma         X__.3 Arthrographis    Eremomyces
## (Intercept)            1.426131e-05  2.878223e-06  2.303282e-05  5.360480e-05
## format_ITS_L6$Group11 -1.670547e-05 -1.181649e-06  6.253889e-05  2.269130e-05
## format_ITS_L6$Group12 -5.384372e-06 -1.181649e-06 -7.060044e-05 -4.717535e-05
## format_ITS_L6$Group13 -1.670547e-05 -1.181649e-06 -6.857149e-05 -4.048704e-05
## dph                    1.286403e-07 -8.929338e-08  2.503559e-06 -3.383920e-07
##                               X__.4 Camarosporidiella         X__.5
## (Intercept)            1.357802e-03      3.116408e-06 -2.585721e-06
## format_ITS_L6$Group11  1.526312e-03     -1.325680e-06 -4.865077e-06
## format_ITS_L6$Group12 -1.271993e-03     -1.325680e-06  1.161579e-05
## format_ITS_L6$Group13 -8.579561e-04     -1.325680e-06 -1.885635e-06
## dph                    3.599543e-05     -9.424880e-08  3.921473e-07
##                        Coniothyrium   Corynespora  Pyrenochaeta
## (Intercept)            8.744017e-05  5.073200e-05  1.611107e-04
## format_ITS_L6$Group11 -5.995951e-05 -5.094110e-05 -6.679596e-05
## format_ITS_L6$Group12 -4.342446e-05 -7.706064e-06 -1.364848e-04
## format_ITS_L6$Group13  2.693406e-05  1.095883e-04 -1.684514e-04
## dph                    1.800710e-06  1.100531e-08  1.411720e-06
##                       Pyrenochaetopsis         X__.6 Dictyosporium
## (Intercept)               1.439359e-04  6.211162e-06  2.947244e-05
## format_ITS_L6$Group11     1.204246e-04 -3.286280e-06  2.398508e-04
## format_ITS_L6$Group12    -1.051836e-04 -3.286280e-06 -8.686088e-05
## format_ITS_L6$Group13    -3.194058e-07 -3.286280e-06 -9.871857e-05
## dph                      -1.373463e-06 -1.539412e-07  3.644533e-06
##                       unidentified.2         X__.7     Didymella  Neoascochyta
## (Intercept)             2.153576e-05  0.0021458137  4.060145e-04  6.077280e-06
## format_ITS_L6$Group11  -1.456507e-05  0.0009054751  1.042503e-04  2.096415e-05
## format_ITS_L6$Group12   3.552568e-05 -0.0013040762 -1.766273e-04  4.451797e-06
## format_ITS_L6$Group13  -6.395541e-06 -0.0006095053  3.188863e-05 -1.529750e-05
## dph                    -3.668784e-07  0.0001212441  5.777221e-07  4.852745e-07
##                               Phoma Stagonosporopsis         X__.8
## (Intercept)            2.805092e-05     3.101131e-04  5.097329e-05
## format_ITS_L6$Group11 -2.658030e-05     2.707068e-04  7.868441e-05
## format_ITS_L6$Group12 -2.658030e-05    -2.356475e-04 -5.454864e-05
## format_ITS_L6$Group13  7.974090e-05     9.928246e-05  1.052827e-06
## dph                   -7.740112e-08    -2.948139e-06  1.267572e-06
##                          Aporospora      Kalmusia Paraphaeosphaeria
## (Intercept)            1.717946e-05 -3.303894e-07      1.003993e-04
## format_ITS_L6$Group11  1.337013e-05 -1.314462e-06      1.475702e-04
## format_ITS_L6$Group12 -1.456048e-06 -1.314462e-06     -9.100970e-05
## format_ITS_L6$Group13 -1.584826e-05 -1.314462e-06     -2.562709e-05
## dph                   -7.006287e-08  8.657112e-08      2.897641e-07
##                       Pseudopithomyces     Darksidea  Lentithecium
## (Intercept)               1.480752e-04  1.431262e-04  3.266406e-05
## format_ITS_L6$Group11    -2.370036e-05  1.515250e-04 -2.163108e-05
## format_ITS_L6$Group12    -9.963892e-05 -7.714841e-05  2.962548e-05
## format_ITS_L6$Group13    -4.644591e-05 -1.030126e-04 -1.130431e-05
## dph                      -2.549278e-06 -1.072916e-06 -5.766192e-07
##                         Poaceascoma         X__.9   Heterospora Leptosphaeria
## (Intercept)            5.566494e-05  2.285243e-04  2.081898e-05  1.408879e-04
## format_ITS_L6$Group11 -1.028272e-05  2.449083e-04 -6.453192e-06  9.921197e-04
## format_ITS_L6$Group12  3.345982e-05 -8.310756e-05 -9.335699e-06 -3.811621e-04
## format_ITS_L6$Group13 -9.648451e-06 -8.171786e-05  4.269352e-06 -3.214409e-04
## dph                   -1.254610e-06 -7.610429e-06 -7.237513e-08  1.637879e-05
##                          Plenodomus        X__.10 Biappendiculispora
## (Intercept)            4.156398e-04  2.476022e-06      -5.415395e-05
## format_ITS_L6$Group11  5.379315e-04 -2.933784e-06       1.352600e-04
## format_ITS_L6$Group12 -3.639505e-04 -2.933784e-06      -4.928501e-05
## format_ITS_L6$Group13 -3.435128e-04 -2.933784e-06      -3.910001e-05
## dph                    3.554780e-06  2.409272e-08       5.444156e-06
##                         Lophiotrema  Byssothecium        X__.11   Acrocalymma
## (Intercept)            1.027160e-05 -3.621006e-05  1.493592e-06 -1.413684e-04
## format_ITS_L6$Group11  4.494151e-05  2.817685e-04 -2.231762e-06  5.829272e-04
## format_ITS_L6$Group12 -9.472811e-06 -1.228714e-04  4.632966e-06 -2.472750e-04
## format_ITS_L6$Group13 -1.834595e-05 -1.228714e-04 -2.231762e-06 -2.472750e-04
## dph                    6.259577e-07  8.372708e-06  3.885106e-08  2.045491e-05
##                       Multiseptospora     Periconia        X__.12
## (Intercept)              2.857817e-06  2.874272e-03  5.074112e-05
## format_ITS_L6$Group11   -1.049540e-06  1.432524e-03  7.461100e-06
## format_ITS_L6$Group12   -1.049540e-06 -2.518976e-03  1.144853e-05
## format_ITS_L6$Group13   -8.427261e-07 -8.810506e-04 -2.644780e-05
## dph                     -9.517244e-08  5.187939e-06  1.102620e-06
##                       Chaetosphaeronema    Leptospora Ophiobolopsis
## (Intercept)                2.262908e-04  2.808909e-04 -2.068678e-05
## format_ITS_L6$Group11      3.760946e-04  2.324459e-04  5.468546e-05
## format_ITS_L6$Group12     -1.585809e-04 -6.010540e-05 -1.972663e-05
## format_ITS_L6$Group13     -1.680371e-04 -8.122044e-05 -1.972663e-05
## dph                       -2.607749e-06 -8.876851e-06  2.127021e-06
##                       Ophiosphaerella     Paraphoma Phaeosphaeria   Septoriella
## (Intercept)              1.067096e-05  3.329029e-03  1.044917e-04  6.185489e-06
## format_ITS_L6$Group11    7.262698e-05  1.850247e-03  4.289772e-05 -6.716713e-06
## format_ITS_L6$Group12   -3.424561e-05  2.730394e-04 -4.682885e-05 -2.791170e-06
## format_ITS_L6$Group13   -3.705210e-05 -1.801287e-03 -5.766782e-06 -6.716713e-06
## dph                      1.388481e-06  3.248219e-05 -2.136451e-06  2.795920e-08
##                           Setophoma unidentified.3        X__.13    Alternaria
## (Intercept)            2.535435e-04   4.999779e-05  3.410953e-05  1.600485e-02
## format_ITS_L6$Group11  3.525159e-04  -1.836182e-05 -3.449498e-05  1.050080e-02
## format_ITS_L6$Group12 -1.773067e-04   3.259263e-05  8.115228e-05  3.204302e-04
## format_ITS_L6$Group13 -1.509092e-04  -4.574190e-06 -1.068712e-05 -8.535520e-03
## dph                   -1.588860e-06  -1.665051e-06  9.792895e-08  9.849687e-05
##                           Bipolaris  Cochliobolus    Curvularia
## (Intercept)            5.223283e-05  2.401375e-05  7.399842e-05
## format_ITS_L6$Group11  9.108066e-05 -9.979301e-06  2.857316e-04
## format_ITS_L6$Group12 -5.105537e-05 -9.979301e-06 -1.762717e-04
## format_ITS_L6$Group13 -3.073425e-05  2.954223e-05 -1.972757e-05
## dph                    7.592295e-09 -7.386550e-07  7.623782e-06
##                       Dichotomophthora   Exserohilum     Pleospora
## (Intercept)               5.826241e-05  4.154689e-05  1.063603e-03
## format_ITS_L6$Group11    -3.934364e-05  1.862302e-05 -8.674436e-05
## format_ITS_L6$Group12    -3.653677e-05 -3.649238e-05 -1.522646e-04
## format_ITS_L6$Group13     1.152241e-04  1.285183e-05 -5.241125e-04
## dph                      -9.957244e-07  4.203490e-07 -2.801605e-05
##                         Stemphylium        X__.14    Monodictys    Nigrograna
## (Intercept)            2.939636e-05  4.655380e-06  1.540329e-06  0.0034217044
## format_ITS_L6$Group11 -1.202947e-05 -3.019758e-05 -3.560237e-06  0.0037698889
## format_ITS_L6$Group12  3.001786e-05  2.745803e-05 -3.560237e-06 -0.0012566296
## format_ITS_L6$Group13 -9.620846e-06  2.105086e-05 -3.560237e-06 -0.0012566296
## dph                   -9.140467e-07  1.344326e-06  1.063109e-07 -0.0001139513
##                              X__.15      Preussia     Sporormia  Sporormiella
## (Intercept)            2.502338e-04  0.0006308051  5.463058e-06  5.667821e-05
## format_ITS_L6$Group11  6.211663e-04  0.0014585506 -5.088328e-07 -2.205854e-05
## format_ITS_L6$Group12 -4.245294e-04 -0.0023046570 -3.237854e-06 -7.422683e-05
## format_ITS_L6$Group13 -3.696929e-04 -0.0014815838 -3.237854e-06  4.382052e-05
## dph                    1.305424e-05  0.0001189495 -1.171160e-07  1.682808e-06
##                       Westerdykella unidentified.4    Roussoella        Torula
## (Intercept)            1.917404e-06   8.786612e-04  3.981866e-05  8.095863e-06
## format_ITS_L6$Group11 -1.071054e-05   1.291850e-03  4.825005e-05 -1.678192e-06
## format_ITS_L6$Group12 -9.900891e-06  -1.355704e-03 -1.654797e-05 -4.277259e-06
## format_ITS_L6$Group13  3.132198e-05  -8.921409e-04 -1.515411e-05 -4.277259e-06
## dph                    4.627968e-07   3.753807e-05 -1.224773e-06 -2.009791e-07
##                       unidentified.5  Spissiomyces        X__.16    Ochroconis
## (Intercept)             1.284954e-04 -1.924694e-06  4.703200e-05  8.253216e-04
## format_ITS_L6$Group11   1.006148e-04  1.558929e-06  2.686083e-04  2.302797e-04
## format_ITS_L6$Group12  -1.492552e-04  1.644859e-06 -1.241449e-04  7.217775e-06
## format_ITS_L6$Group13  -3.029864e-05 -1.601894e-06 -1.107257e-04 -2.839647e-04
## dph                     1.596334e-06  1.856099e-07  4.058571e-06  1.883631e-05
##                              X__.17        X__.18 Cyphellophora        X__.19
## (Intercept)            4.333250e-04  1.666512e-04  2.986976e-05  1.559362e-05
## format_ITS_L6$Group11 -5.348088e-04 -5.920702e-05  3.204228e-04 -6.014004e-06
## format_ITS_L6$Group12  1.242503e-03 -5.510163e-05 -1.602994e-04 -1.784380e-05
## format_ITS_L6$Group13 -1.150976e-04  2.680874e-05 -1.436458e-04 -1.762156e-05
## dph                    2.448524e-05 -8.036670e-07  7.024039e-06  1.184304e-07
##                       Cladophialophora  Coniosporium     Exophiala
## (Intercept)               8.172128e-05  5.972275e-04  4.616580e-04
## format_ITS_L6$Group11     1.590963e-04  4.457692e-05  1.139917e-04
## format_ITS_L6$Group12    -5.769024e-05 -1.910506e-04 -2.190690e-04
## format_ITS_L6$Group13    -4.785461e-05  6.188774e-06 -1.447327e-04
## dph                      -1.264791e-06 -6.885256e-06 -1.772395e-06
##                       Minimelanolocus   Phialophora      Veronaea
## (Intercept)              2.062745e-05  1.178694e-04  2.236493e-05
## format_ITS_L6$Group11    1.118355e-05  2.069573e-04  1.480744e-05
## format_ITS_L6$Group12    9.587893e-06 -1.807862e-04 -1.361357e-05
## format_ITS_L6$Group13   -7.039259e-06 -1.775385e-04 -1.361357e-05
## dph                      3.073894e-07  3.621748e-06 -4.605978e-07
##                       unidentified.6        X__.20    Bradymyces        Knufia
## (Intercept)             9.977120e-06  3.971273e-05  7.309781e-05  7.188906e-04
## format_ITS_L6$Group11  -3.505892e-06 -3.537978e-05 -5.516844e-05 -2.803041e-04
## format_ITS_L6$Group12  -6.062969e-06 -7.993365e-06  3.531410e-05  1.818706e-03
## format_ITS_L6$Group13  -3.892395e-06  9.463804e-05 -3.708277e-05 -7.232396e-04
## dph                    -2.060080e-07  6.814716e-07  9.216352e-08  2.635496e-05
##                        Trichomerium unidentified.7 unidentified.8        X__.21
## (Intercept)            6.290622e-06  -8.103239e-06   8.081371e-06  3.442122e-04
## format_ITS_L6$Group11 -5.202323e-06  -1.570105e-05  -1.877660e-05 -1.145345e-05
## format_ITS_L6$Group12  1.560697e-05   2.016044e-06   2.440752e-05 -1.645988e-04
## format_ITS_L6$Group13 -5.202323e-06   2.938606e-05  -6.471575e-06  7.598235e-05
## dph                   -5.727887e-08   1.252857e-06   9.151642e-07 -3.054712e-06
##                              X__.22   Aspergillus   Penicillium Phialosimplex
## (Intercept)            4.680829e-04  0.0274393414  1.234156e-02  1.442646e-06
## format_ITS_L6$Group11 -3.767319e-04  0.0094803814 -6.317044e-03 -9.756906e-07
## format_ITS_L6$Group12 -5.803005e-05 -0.0137077143  6.434210e-04 -9.756906e-07
## format_ITS_L6$Group13  8.141801e-04  0.0011161710  1.224988e-02  2.927072e-06
## dph                    7.770297e-07  0.0007264459 -9.400648e-05 -2.457659e-08
##                           Xeromyces   Sagenomella  Talaromyces   Thermomyces
## (Intercept)            2.169562e-04  1.411174e-05  0.057958013  1.128683e-04
## format_ITS_L6$Group11 -2.274970e-04 -1.352671e-05 -0.013382524  2.481589e-04
## format_ITS_L6$Group12  8.208476e-06  3.284534e-05  0.007041574 -1.522342e-04
## format_ITS_L6$Group13  4.140226e-04 -1.352671e-05  0.022587507 -6.773088e-05
## dph                    5.547785e-07 -3.079110e-08 -0.001784342  2.424973e-06
##                        Xerochrysium unidentified.9  Mycocalicium        X__.23
## (Intercept)            5.223105e-04   3.617784e-05  1.147143e-05  9.332743e-05
## format_ITS_L6$Group11 -1.378395e-04   6.541073e-06  4.208200e-05  1.198640e-04
## format_ITS_L6$Group12  1.061396e-04  -7.638251e-06 -2.782409e-05 -7.175152e-05
## format_ITS_L6$Group13  2.115385e-04   1.451172e-05 -2.782409e-05 -5.602951e-05
## dph                   -1.444262e-05  -4.021323e-07  8.606660e-07 -1.135574e-06
##                              X__.24 unidentified.10  Arachnomyces
## (Intercept)            1.588840e-04    9.207056e-05  2.006983e-04
## format_ITS_L6$Group11  1.698566e-04    2.303265e-04  2.301388e-04
## format_ITS_L6$Group12 -2.167391e-04   -1.491072e-04 -1.799845e-04
## format_ITS_L6$Group13 -1.790082e-04   -4.164784e-05 -1.134361e-04
## dph                    4.391480e-06    3.320695e-06 -1.090199e-06
##                       unidentified.11    Ctenomyces Gymnoascoideus
## (Intercept)              3.884883e-06  7.316639e-04   5.083602e-06
## format_ITS_L6$Group11   -8.333054e-06  5.667960e-04   6.844455e-06
## format_ITS_L6$Group12   -8.333054e-06 -5.739533e-04  -2.939166e-06
## format_ITS_L6$Group13   -8.333054e-06 -2.333253e-04  -2.939166e-06
## dph                      2.341142e-07 -2.082995e-06  -1.128651e-07
##                          Gymnoascus Kraurogymnocarpa  Testudomyces
## (Intercept)            8.726085e-04    -4.118468e-08  1.609697e-06
## format_ITS_L6$Group11  5.521446e-04    -1.506542e-06 -1.810833e-06
## format_ITS_L6$Group12 -2.714081e-05    -1.506542e-06 -1.810833e-06
## format_ITS_L6$Group13 -6.700889e-04    -8.398518e-07 -1.810833e-06
## dph                    1.725624e-05     8.145931e-08  1.058615e-08
##                       unidentified.12        X__.25   Amauroascus   Aphanoascus
## (Intercept)              2.207915e-05 -5.234928e-06  8.189267e-05  1.783306e-03
## format_ITS_L6$Group11    1.808796e-05 -5.430097e-06  3.622849e-06 -6.952931e-05
## format_ITS_L6$Group12   -1.469803e-05  1.188592e-05 -9.948777e-05  2.834077e-03
## format_ITS_L6$Group13   -9.815051e-06 -4.318947e-06  1.423430e-05 -1.002448e-03
## dph                     -3.884803e-07  5.613171e-07  1.862249e-06  3.592358e-05
##                          Auxarthron     Mallochia Chrysosporium   Malbranchea
## (Intercept)            7.517012e-04 -1.030201e-07  1.569536e-03  2.097113e-05
## format_ITS_L6$Group11  2.305708e-04 -1.392478e-06  1.526790e-03 -2.054924e-05
## format_ITS_L6$Group12 -5.007367e-04 -1.392478e-06 -1.478980e-03 -1.166693e-05
## format_ITS_L6$Group13 -4.879655e-04 -1.392478e-06 -2.654581e-04 -2.163406e-05
## dph                   -9.345121e-06  7.871042e-08  5.243074e-06  3.489083e-08
##                         Spiromastix unidentified.13 unidentified.14
## (Intercept)            4.023582e-06    1.499149e-03    2.114377e-06
## format_ITS_L6$Group11 -1.437523e-05    1.858912e-03   -3.693894e-06
## format_ITS_L6$Group12 -1.528801e-05   -1.658944e-03   -3.693894e-06
## format_ITS_L6$Group13 -1.646806e-05   -9.837692e-04   -3.693894e-06
## dph                    6.549724e-07    4.323028e-05    8.313247e-08
##                        Pyxidiophora Botryolepraria        X__.26      Erysiphe
## (Intercept)            2.092052e-04   6.723935e-05  4.738158e-04  3.128586e-05
## format_ITS_L6$Group11 -5.456348e-05   3.298080e-05  4.702083e-04 -3.704167e-05
## format_ITS_L6$Group12 -1.706234e-05   7.103696e-06 -1.610015e-04  1.051259e-06
## format_ITS_L6$Group13  1.596985e-04  -2.469382e-05 -8.990924e-05  7.303208e-05
## dph                   -5.916541e-06  -2.239238e-06 -1.256342e-05  3.029373e-07
##                        Phyllactinia   Podosphaera        X__.27        X__.28
## (Intercept)            6.753625e-07 -1.047322e-06  6.887190e-04 -1.825536e-05
## format_ITS_L6$Group11 -3.485556e-06 -4.356415e-06 -9.441292e-04  8.975005e-05
## format_ITS_L6$Group12 -2.336483e-06  3.975530e-06  2.412540e-03 -3.921860e-05
## format_ITS_L6$Group13 -3.485556e-06  4.737300e-06 -5.371338e-04 -4.227226e-05
## dph                    1.479049e-07  2.844072e-07  2.258452e-05  3.381256e-06
##                       Articulospora   Scytalidium  Tetracladium        X__.29
## (Intercept)            2.127296e-05  4.503909e-05  0.0210380918  6.834732e-05
## format_ITS_L6$Group11 -7.537807e-06  4.046908e-05  0.0145227017  6.491802e-05
## format_ITS_L6$Group12 -1.610478e-05 -2.187995e-05 -0.0082016857 -6.796117e-05
## format_ITS_L6$Group13  1.887495e-06 -2.315326e-05 -0.0132499306 -1.505307e-05
## dph                   -2.720091e-07 -1.151886e-06  0.0004119824  1.766289e-06
##                         Amphobotrys     Cadophora   Leohumicola      Cistella
## (Intercept)            3.930207e-05  2.066906e-03  3.572917e-03  4.017875e-04
## format_ITS_L6$Group11  3.808931e-05 -2.491163e-03  6.366979e-06  2.493435e-04
## format_ITS_L6$Group12 -1.443378e-05 -2.453671e-03 -1.288344e-03 -4.972897e-04
## format_ITS_L6$Group13 -1.443378e-05 -2.313852e-03 -1.639901e-03 -1.061439e-04
## dph                   -1.308857e-06  2.329596e-05  5.161793e-05  8.436869e-06
##                          Setoscypha   Myxotrichum  Oidiodendron      Botrytis
## (Intercept)            1.496751e-05  6.066324e-04  2.702655e-04  2.298486e-04
## format_ITS_L6$Group11 -5.496855e-06 -8.449352e-04  5.539388e-04  1.569252e-04
## format_ITS_L6$Group12  7.219537e-06  2.077180e-03 -2.033173e-04 -5.744450e-05
## format_ITS_L6$Group13  3.774173e-06 -4.288515e-04 -1.341558e-04  3.547774e-05
## dph                   -4.984554e-07  1.944278e-05  1.710158e-06 -2.397288e-06
##                              X__.30      Geomyces Pseudeurotium
## (Intercept)            5.025900e-05  4.909098e-06  9.987223e-05
## format_ITS_L6$Group11 -3.075597e-05 -5.088571e-06  1.112637e-04
## format_ITS_L6$Group12  1.419416e-05 -5.088571e-06 -5.624313e-05
## format_ITS_L6$Group13  4.689153e-05  4.344585e-06 -6.094686e-05
## dph                    6.918114e-07  9.445953e-09 -1.450011e-06
##                       Pseudogymnoascus unidentified.15    Thelebolus
## (Intercept)               0.0133744329    7.538940e-07  5.989520e-04
## format_ITS_L6$Group11     0.0047155415   -9.323860e-07  6.948743e-04
## format_ITS_L6$Group12    -0.0009337328   -6.871260e-07 -5.042229e-04
## format_ITS_L6$Group13    -0.0086950682    2.551898e-06 -4.526282e-04
## dph                       0.0002628771    9.394317e-09  1.367544e-06
##                              X__.31        X__.32  Arthrobotrys    Dactylaria
## (Intercept)            2.519684e-07  1.003235e-06  3.284992e-06  3.046013e-06
## format_ITS_L6$Group11  1.760536e-07 -7.501214e-07 -1.447962e-06 -1.350738e-06
## format_ITS_L6$Group12 -1.338951e-07 -9.038777e-07 -1.447962e-06 -1.350738e-06
## format_ITS_L6$Group13 -1.338951e-07 -9.038777e-07 -1.447962e-06 -1.350738e-06
## dph                   -6.214383e-09 -5.229322e-09 -9.668581e-08 -8.922498e-08
##                       unidentified.16 unidentified.17        X__.33
## (Intercept)              1.032923e-04    1.325909e-05  6.032478e-05
## format_ITS_L6$Group11    6.747093e-05    1.576508e-05 -3.506451e-05
## format_ITS_L6$Group12   -6.027037e-05   -6.005195e-06 -3.260733e-05
## format_ITS_L6$Group13    1.813987e-05   -6.005195e-06  1.309462e-05
## dph                     -2.264313e-06   -3.817838e-07 -8.838265e-07
##                              X__.34     Ascobolus Cephaliophora    Iodophanus
## (Intercept)            9.465868e-05  1.191678e-03  3.455204e-04  1.707261e-05
## format_ITS_L6$Group11 -1.043271e-05  1.040289e-03  3.900496e-04  1.276683e-06
## format_ITS_L6$Group12 -9.995385e-05 -3.716620e-04 -2.385420e-04 -1.266625e-05
## format_ITS_L6$Group13  9.359009e-05 -5.193283e-04 -1.840828e-04  1.936746e-05
## dph                    5.385368e-06 -4.536904e-06 -3.280944e-06 -2.319136e-07
##                       Kalaharituber        Peziza      Terfezia unidentified.18
## (Intercept)            2.586540e-07  7.822315e-05  3.194932e-05    1.464325e-05
## format_ITS_L6$Group11 -1.143508e-07  7.054787e-05  5.316869e-05    1.383612e-05
## format_ITS_L6$Group12 -1.143508e-07 -1.509773e-05 -1.060393e-04   -1.755929e-05
## format_ITS_L6$Group13 -1.143508e-07 -8.025409e-05 -7.691250e-05   -1.755929e-05
## dph                   -7.594906e-09  7.550049e-07  3.899472e-06    1.534760e-07
##                            Coprotus        X__.35   Cheilymenia       Geopora
## (Intercept)            2.597485e-06  7.619918e-05  4.050417e-04 -1.357947e-05
## format_ITS_L6$Group11 -1.170928e-06 -4.362955e-05  2.472622e-04  6.180817e-05
## format_ITS_L6$Group12 -1.790826e-06 -7.459363e-06 -3.568168e-04 -6.968629e-05
## format_ITS_L6$Group13 -1.390811e-06  2.809771e-05 -2.718149e-04 -7.434061e-05
## dph                   -4.245575e-08  9.911642e-07  4.937041e-06  7.281182e-06
##                            Heydenia Lasiobolidium  Paurocotylis  Pseudaleuria
## (Intercept)            2.155382e-03  0.0006061832  5.568910e-05  1.293006e-05
## format_ITS_L6$Group11  9.465750e-04  0.0002090925  4.152906e-05  1.959802e-05
## format_ITS_L6$Group12 -5.022454e-04 -0.0006412767 -3.204621e-05 -8.021843e-06
## format_ITS_L6$Group13 -1.281442e-03 -0.0003766599 -3.204621e-05 -8.021843e-06
## dph                    6.218618e-05  0.0000070872 -1.244363e-06 -2.583274e-07
##                           Pulvinula   Scutellinia unidentified.19  Pneumocystis
## (Intercept)            8.040360e-04  0.0076520347    2.364402e-06  1.033772e-04
## format_ITS_L6$Group11  6.654987e-04  0.0051599670    1.037483e-04 -1.436091e-04
## format_ITS_L6$Group12 -8.374394e-04 -0.0028115046   -2.809809e-05  3.960511e-04
## format_ITS_L6$Group13 -2.495777e-04 -0.0060029236   -4.167057e-05 -1.656029e-04
## dph                    3.910736e-06  0.0001521029    2.812246e-06  3.386590e-06
##                              X__.36  Debaryomyces   Hyphopichia    Meyerozyma
## (Intercept)            0.0183696635  9.909657e-05  2.884664e-04  9.911786e-05
## format_ITS_L6$Group11 -0.0066690613 -3.634970e-07 -1.160239e-04 -7.229407e-05
## format_ITS_L6$Group12  0.0017423497 -4.289571e-05  6.375883e-05 -9.709753e-05
## format_ITS_L6$Group13  0.0033072699  7.950456e-05  2.683648e-04  1.812070e-04
## dph                   -0.0005029371 -1.880263e-06 -3.371348e-06  3.473527e-06
##                         Millerozyma unidentified.20    Clavispora      Kodamaea
## (Intercept)            6.219968e-06   -4.256825e-07  4.294816e-03  1.972492e-04
## format_ITS_L6$Group11 -2.284299e-06   -1.562182e-06 -9.315951e-04 -8.036525e-05
## format_ITS_L6$Group12 -1.375137e-06   -1.064893e-06 -3.621016e-05 -9.126742e-06
## format_ITS_L6$Group13  5.943735e-06    4.189256e-06  1.251000e-03  4.516351e-06
## dph                   -2.071405e-07    1.046244e-07 -1.113555e-04 -6.151788e-06
##                       Cyberlindnera      Starmera Wickerhamomyces  Eremothecium
## (Intercept)            1.285606e-05  4.664108e-04    3.911506e-05  2.670410e-06
## format_ITS_L6$Group11 -4.721422e-06 -1.724916e-04   -1.734682e-05 -3.028843e-06
## format_ITS_L6$Group12 -4.721422e-06  3.705439e-04    9.489678e-06  9.086529e-06
## format_ITS_L6$Group13  9.247124e-06 -1.288926e-04   -1.340198e-06 -3.028843e-06
## dph                   -4.281391e-07 -1.546943e-05   -1.081001e-06  1.886490e-08
##                        Issatchenkia  Kazachstania Saccharomyces
## (Intercept)            2.582612e-07 -3.382931e-05  5.510026e-04
## format_ITS_L6$Group11 -4.431720e-07 -1.171440e-04 -6.302903e-04
## format_ITS_L6$Group12 -4.431720e-07  3.106736e-04 -2.062065e-04
## format_ITS_L6$Group13  1.329516e-06 -7.638554e-05  1.434333e-03
## dph                    9.732150e-09  7.945964e-06  7.703496e-06
##                       Zygosaccharomyces      Candida       Diutina
## (Intercept)                2.625116e-04  0.082942219  0.0079485242
## format_ITS_L6$Group11      2.679150e-04 -0.129288227 -0.0003948410
## format_ITS_L6$Group12     -8.040024e-05  0.202513514 -0.0006552694
## format_ITS_L6$Group13     -9.640803e-05  0.038433212 -0.0024604978
## dph                       -8.742290e-06  0.004590134 -0.0002551455
##                       Sympodiomyces  Blastobotrys Trichomonascus     Zygoascus
## (Intercept)            1.738559e-05  6.029490e-06   2.125425e-05  1.673504e-03
## format_ITS_L6$Group11 -7.382691e-06 -4.077866e-06  -2.129425e-05 -3.882710e-04
## format_ITS_L6$Group12  3.710800e-06  9.186585e-06   9.321656e-06  7.814815e-04
## format_ITS_L6$Group13 -4.043347e-06 -1.030852e-06   3.326685e-05 -5.017472e-04
## dph                   -5.264685e-07 -1.027170e-07   2.105489e-09 -5.570211e-05
##                              X__.37 unidentified.21   Coniochaeta
## (Intercept)            0.0053919915   -6.483416e-07  7.687546e-05
## format_ITS_L6$Group11  0.0033087532   -8.622284e-07 -4.511140e-05
## format_ITS_L6$Group12 -0.0031072537    1.429607e-06 -4.515934e-05
## format_ITS_L6$Group13 -0.0023129014   -8.622284e-07  1.172958e-05
## dph                    0.0001445568    7.950368e-08 -1.274366e-06
##                       unidentified.22     Diaporthe Cryptosphaeria
## (Intercept)              1.572384e-05  6.146147e-04   3.221399e-06
## format_ITS_L6$Group11    1.492029e-04 -4.863215e-04  -2.083537e-06
## format_ITS_L6$Group12   -5.678420e-05  1.039698e-03  -2.083537e-06
## format_ITS_L6$Group13   -4.375006e-05 -5.404285e-05  -2.083537e-06
## dph                      2.161071e-06 -3.989692e-06  -5.988747e-08
##                           Cytospora unidentified.23 Colletotrichum
## (Intercept)            1.985799e-06    2.012010e-06   1.221790e-03
## format_ITS_L6$Group11 -8.152660e-07   -1.829178e-06  -3.830647e-04
## format_ITS_L6$Group12 -8.152660e-07   -1.829178e-06   1.751898e-03
## format_ITS_L6$Group13 -8.152660e-07   -1.829178e-06  -4.975111e-04
## dph                   -6.160700e-08   -9.622696e-09   1.075407e-05
##                              X__.38 Acrostalagmus Gibellulopsis       Lectera
## (Intercept)            1.269074e-05  7.737452e-04  0.0118611040  3.013154e-04
## format_ITS_L6$Group11 -1.597519e-06  7.683290e-04  0.0103636090  3.303105e-04
## format_ITS_L6$Group12 -7.082491e-06 -5.437412e-04 -0.0132371933 -4.086291e-04
## format_ITS_L6$Group13  8.263856e-06 -3.070764e-04 -0.0042108447 -1.307817e-04
## dph                   -2.951707e-07 -1.124387e-05  0.0004092644  6.896453e-06
##                       Plectosphaerella    Sodiomyces  Verticillium
## (Intercept)               0.0323282829  4.956478e-05  0.0123637398
## format_ITS_L6$Group11     0.0210340629  6.395444e-05  0.0066346052
## format_ITS_L6$Group12    -0.0279948443 -5.937703e-05 -0.0030231487
## format_ITS_L6$Group13    -0.0134856329 -5.938496e-05 -0.0040707473
## dph                       0.0006467963  8.127161e-07 -0.0003140498
##                       unidentified.24        X__.39        X__.40  Clonostachys
## (Intercept)              4.395704e-05  1.121961e-03  3.382375e-05  5.634751e-04
## format_ITS_L6$Group11   -6.918136e-05 -6.889091e-04 -3.711647e-05  2.415787e-05
## format_ITS_L6$Group12   -6.918136e-05 -8.703311e-05 -4.681469e-05  1.499261e-03
## format_ITS_L6$Group13   -6.748664e-05 -1.893145e-04 -1.563011e-06 -6.181971e-04
## dph                      1.327596e-06  1.098626e-05  6.837337e-07  4.836867e-05
##                          Geosmithia    Gliomastix Hydropisphaera   Nectriopsis
## (Intercept)            1.482040e-04  2.439126e-05   2.271671e-05  1.871866e-03
## format_ITS_L6$Group11  5.341444e-04 -1.051352e-05  -2.709044e-05  1.970383e-04
## format_ITS_L6$Group12 -3.179971e-04 -1.751918e-05  -2.926008e-05  7.962402e-04
## format_ITS_L6$Group13 -2.253059e-04 -1.600801e-05  -2.926008e-05 -9.364110e-04
## dph                    1.211092e-05 -3.616886e-07   3.443878e-07  4.341472e-05
##                             Selinia  Verrucostoma unidentified.25        X__.41
## (Intercept)           -1.023742e-05  1.401556e-05    6.344078e-05  1.916233e-06
## format_ITS_L6$Group11  4.444119e-05 -1.249156e-05    1.989656e-04 -2.106682e-06
## format_ITS_L6$Group12 -4.863950e-05 -1.249156e-05   -7.791949e-05 -2.106682e-06
## format_ITS_L6$Group13  1.742853e-06 -1.249156e-05   -6.236259e-05  3.934694e-06
## dph                    3.710833e-06 -8.021078e-08    7.620372e-07  1.002363e-08
##                         Aschersonia Metacordyceps   Metarhizium  Paecilomyces
## (Intercept)            7.764429e-06  1.976539e-05  9.421523e-04  1.458864e-05
## format_ITS_L6$Group11 -6.802955e-06  1.257978e-05  3.504452e-04 -5.357716e-06
## format_ITS_L6$Group12 -1.195250e-05 -4.470440e-05  8.563485e-04  1.958081e-06
## format_ITS_L6$Group13  4.179336e-05  1.632416e-05 -7.712758e-04  6.454354e-06
## dph                    9.664359e-07  1.919320e-06  4.565509e-05 -4.858382e-07
##                              X__.42     Beauveria  Engyodontium Lecanicillium
## (Intercept)            6.037528e-05  3.392903e-03  2.774525e-06  5.696080e-04
## format_ITS_L6$Group11  5.734034e-05  2.013313e-03 -2.067677e-06  2.928684e-04
## format_ITS_L6$Group12 -2.217298e-05 -1.208429e-03  1.833830e-06 -3.183865e-05
## format_ITS_L6$Group13 -2.217298e-05 -1.076753e-03 -2.558942e-06 -3.113991e-05
## dph                   -2.010648e-06 -5.450466e-05 -1.134645e-08 -1.260758e-05
##                       Simplicillium   Monocillium   Trichoderma        X__.43
## (Intercept)            1.502190e-04  2.246478e-04  0.0077949993  3.169574e-04
## format_ITS_L6$Group11  1.616630e-04 -3.902062e-04 -0.0032022741  3.759571e-04
## format_ITS_L6$Group12 -6.543347e-05  8.186451e-04  0.0005218427 -3.593968e-04
## format_ITS_L6$Group13 -6.543347e-05 -2.813507e-04  0.0051041435 -2.368580e-04
## dph                   -4.462397e-06  1.037356e-05 -0.0002024864  4.334916e-06
##                          Acremonium Emericellopsis    Fusariella   Olpitrichum
## (Intercept)            4.073240e-03   1.214171e-04  4.293306e-03  1.117994e-04
## format_ITS_L6$Group11  3.209565e-05   2.283365e-04  1.032582e-03  6.508862e-05
## format_ITS_L6$Group12 -1.525131e-03  -2.126566e-04  5.604697e-04 -2.024123e-04
## format_ITS_L6$Group13 -1.084522e-03  -5.449152e-05 -2.052742e-03 -9.967085e-05
## dph                    3.664809e-05   5.895233e-06  6.435272e-05  4.769102e-06
##                         Sarocladium  Stanjemonium Trichothecium Ustilaginoidea
## (Intercept)            0.0148332556  4.171852e-06  1.727345e-05   6.210487e-05
## format_ITS_L6$Group11 -0.0063802410 -3.219578e-06 -8.251419e-06   9.393917e-06
## format_ITS_L6$Group12 -0.0043132802 -3.839476e-06 -1.910893e-06   3.099779e-05
## format_ITS_L6$Group13  0.0031804995 -3.839476e-06  1.009113e-05  -1.936606e-05
## dph                   -0.0003339695 -1.749347e-08 -4.299826e-07  -1.819888e-06
##                       unidentified.26        X__.44  Bisifusarium    Cosmospora
## (Intercept)              2.210560e-05  0.0142521093  3.281559e-05  9.957096e-06
## format_ITS_L6$Group11   -5.389392e-06  0.0112889224  3.785849e-05  6.140819e-05
## format_ITS_L6$Group12   -9.152574e-06 -0.0091927281 -1.332990e-05 -4.411191e-05
## format_ITS_L6$Group13    2.271587e-05 -0.0083477565 -8.960445e-06 -3.557091e-05
## dph                     -6.817381e-07  0.0003394838 -9.077603e-07  1.797622e-06
##                       Cylindrocarpon Dactylonectria     Fusarium     Fusicolla
## (Intercept)             1.330857e-04   1.716205e-03  0.194742176  3.907876e-03
## format_ITS_L6$Group11   1.078932e-04  -3.372015e-04 -0.056704136 -1.340082e-03
## format_ITS_L6$Group12  -1.484764e-04   1.354074e-03 -0.016844976  3.721386e-03
## format_ITS_L6$Group13  -2.830938e-05  -1.086605e-03  0.039962860 -2.022831e-03
## dph                     1.506423e-06   3.436675e-05 -0.001930023  8.377666e-05
##                          Gibberella   Ilyonectria       Nectria Neocosmospora
## (Intercept)            0.0026590977  1.066472e-04  5.006610e-04  8.089848e-06
## format_ITS_L6$Group11  0.0014403453  8.579328e-05  9.240602e-04  2.083327e-05
## format_ITS_L6$Group12 -0.0020415341 -2.630287e-05 -6.035029e-04 -8.410495e-06
## format_ITS_L6$Group13 -0.0022184692 -4.071373e-05 -3.394607e-04 -8.410495e-06
## dph                    0.0002034618 -3.470184e-06  1.430404e-05  1.687614e-08
##                          Neonectria     Volutella  Eucasphaeria        X__.45
## (Intercept)            2.045295e-06  4.256510e-05  2.592297e-04  8.154397e-07
## format_ITS_L6$Group11 -8.396921e-07 -2.791792e-05  4.064548e-04 -1.078311e-06
## format_ITS_L6$Group12 -8.396921e-07 -3.939403e-05 -3.287713e-04 -1.078311e-06
## format_ITS_L6$Group13 -8.396921e-07 -5.346842e-05 -1.680877e-04 -1.078311e-06
## dph                   -6.345281e-08  8.051709e-07  1.014553e-05  1.383535e-08
##                          Drechmeria  Harposporium Ophiocordyceps
## (Intercept)            5.116951e-06  2.035736e-05   1.409285e-05
## format_ITS_L6$Group11 -2.562569e-06 -2.659066e-05   1.239772e-05
## format_ITS_L6$Group12 -2.562569e-06 -1.711593e-05  -5.098932e-06
## format_ITS_L6$Group13 -2.562569e-06  1.911516e-05   5.759813e-06
## dph                   -1.344411e-07  4.557416e-07  -5.443413e-08
##                       Purpureocillium        X__.46 Achroiostachys
## (Intercept)              1.293302e-04  1.262010e-03   1.240257e-04
## format_ITS_L6$Group11   -9.062604e-06  8.928789e-04   1.337686e-04
## format_ITS_L6$Group12   -1.508328e-04 -1.455582e-03  -8.537901e-05
## format_ITS_L6$Group13    2.005516e-04 -3.888014e-04  -5.715593e-05
## dph                      2.774535e-06  1.506803e-05  -1.720441e-06
##                             Alfaria   Myrothecium Paramyrothecium  Stachybotrys
## (Intercept)            1.918858e-05 -4.500635e-05    9.367614e-04  1.983510e-03
## format_ITS_L6$Group11 -2.340715e-05  1.695766e-04    5.526916e-04  1.026034e-03
## format_ITS_L6$Group12 -8.537479e-06 -9.344761e-05   -8.782404e-04 -2.189323e-03
## format_ITS_L6$Group13 -2.724844e-05  4.517526e-05   -3.427457e-04 -1.388236e-03
## dph                    4.242030e-07  1.031532e-05    3.350109e-06  2.388662e-05
##                       Striatibotrys unidentified.27  Tilachlidium
## (Intercept)            1.598152e-04    3.742564e-06  4.438751e-05
## format_ITS_L6$Group11  3.543955e-06   -1.741850e-06 -4.870231e-06
## format_ITS_L6$Group12 -1.403535e-04   -1.741850e-06 -1.524744e-05
## format_ITS_L6$Group13 -1.792483e-05   -1.741850e-06 -3.706333e-05
## dph                   -1.024301e-06   -1.053007e-07 -1.372817e-07
##                       unidentified.28        X__.47    Falciphora
## (Intercept)              1.307378e-03  6.811654e-05  3.121463e-05
## format_ITS_L6$Group11    9.990758e-04  5.471709e-05  2.048115e-04
## format_ITS_L6$Group12   -1.518630e-03 -3.410118e-05 -6.827051e-05
## format_ITS_L6$Group13   -2.632768e-04  4.858969e-05 -6.827051e-05
## dph                      2.539858e-05  9.799815e-08  1.950309e-06
##                       Gaeumannomyces    Harpophora   Magnaporthe
## (Intercept)             1.954785e-06  2.643744e-05  1.331095e-05
## format_ITS_L6$Group11   1.410302e-06  2.076409e-05 -5.789421e-05
## format_ITS_L6$Group12  -9.994708e-07 -9.709217e-06 -5.104428e-05
## format_ITS_L6$Group13  -9.994708e-07 -9.709217e-06  8.178864e-05
## dph                    -5.027968e-08 -8.804327e-07  2.346487e-06
##                       Magnaporthiopsis    Ophioceras   Pyricularia
## (Intercept)               2.714282e-04  1.279692e-06 -5.085670e-05
## format_ITS_L6$Group11     3.429472e-04 -5.955894e-07 -1.301088e-04
## format_ITS_L6$Group12    -4.507837e-04 -5.955894e-07 -1.092901e-04
## format_ITS_L6$Group13    -2.320172e-04 -5.955894e-07  3.663766e-04
## dph                       9.439761e-06 -3.600541e-08  9.524501e-06
##                        Slopeiomyces unidentified.29   Melanospora    Aniptodera
## (Intercept)           -3.613387e-06    5.359486e-07  2.977530e-04  8.176861e-07
## format_ITS_L6$Group11 -9.343446e-06   -3.868574e-06  3.990214e-04 -6.545513e-07
## format_ITS_L6$Group12 -9.343446e-06   -3.868574e-06 -4.607584e-04 -1.196962e-06
## format_ITS_L6$Group13 -9.343446e-06   -3.868574e-06 -2.757102e-04 -1.196962e-06
## dph                    6.819386e-07    1.754014e-07  8.579234e-06  1.996187e-08
##                       unidentified.30        X__.48      Acaulium
## (Intercept)              2.221165e-06  6.586468e-05  3.122999e-04
## format_ITS_L6$Group11   -1.000596e-06  8.811614e-05  2.428762e-04
## format_ITS_L6$Group12   -1.000596e-06 -9.297095e-05 -2.695791e-04
## format_ITS_L6$Group13   -1.000596e-06 -2.718222e-05  5.031321e-06
## dph                     -6.424047e-08  1.505946e-06  1.911781e-06
##                       Cephalotrichum       Kernia    Microascus     Petriella
## (Intercept)             2.991703e-04 2.400113e-04  3.112434e-03  4.181066e-06
## format_ITS_L6$Group11   1.318046e-04 3.499753e-05 -1.071762e-03 -1.535507e-06
## format_ITS_L6$Group12  -3.175472e-04 1.325190e-04 -4.450153e-04 -1.077135e-06
## format_ITS_L6$Group13  -2.087720e-04 4.763738e-05  2.745420e-03  4.148149e-06
## dph                     3.643125e-06 8.163573e-06 -3.542247e-05 -1.392399e-07
##                          Pithoascus  Scedosporium Scopulariopsis
## (Intercept)            7.671051e-04  1.819538e-04   6.633063e-05
## format_ITS_L6$Group11 -9.673099e-05  4.050355e-04  -1.021403e-04
## format_ITS_L6$Group12  5.554415e-04 -2.783678e-04  -8.744354e-05
## format_ITS_L6$Group13  7.075496e-05 -2.453216e-04  -2.381469e-05
## dph                    3.273517e-05  1.138842e-05   1.884720e-06
##                       unidentified.31 Cephalotrichiella    Wardomyces
## (Intercept)              1.001749e-04      8.149529e-05  8.872366e-05
## format_ITS_L6$Group11    7.358447e-05      8.378103e-05  9.110206e-05
## format_ITS_L6$Group12   -1.293655e-04     -4.688310e-05 -4.950543e-05
## format_ITS_L6$Group13   -4.746662e-05     -4.626086e-05 -3.968580e-05
## dph                      1.693666e-06     -1.821694e-06 -2.064118e-06
##                        Myrmecridium   Phyllachora        X__.49  Phialemonium
## (Intercept)            1.204308e-04  2.367128e-06  9.904128e-04  3.346396e-07
## format_ITS_L6$Group11  9.686666e-05 -1.856450e-06  1.010137e-03 -4.138689e-07
## format_ITS_L6$Group12 -1.441183e-04 -1.856450e-06  1.535269e-05  1.016814e-06
## format_ITS_L6$Group13 -1.019112e-04  4.441635e-06 -6.307645e-04 -1.890764e-07
## dph                    1.246713e-06 -2.687783e-08  2.670705e-05  4.169964e-09
##                              X__.50   Achaetomium Acrophialophora        Amesia
## (Intercept)            1.129755e-03  2.688490e-05    1.497008e-05  6.444805e-06
## format_ITS_L6$Group11  9.953790e-04 -3.476062e-06   -1.132803e-05 -3.463213e-06
## format_ITS_L6$Group12 -1.197449e-03 -3.885961e-05    8.112690e-06  6.140959e-06
## format_ITS_L6$Group13 -2.587034e-04 -3.885961e-05   -8.935347e-06 -3.463213e-06
## dph                    1.157972e-05  6.302478e-07   -1.916868e-07 -1.569259e-07
##                       Botryotrichum   Chaetomium Dichotomopilus      Humicola
## (Intercept)            0.0113765602  0.009553642   8.446884e-05  0.0030498261
## format_ITS_L6$Group11  0.0024726894  0.010271831   8.262917e-05  0.0027634732
## format_ITS_L6$Group12 -0.0049485821 -0.005716775  -7.338977e-05 -0.0023240553
## format_ITS_L6$Group13 -0.0036059304 -0.003750706  -6.427620e-05 -0.0013014454
## dph                    0.0002950938 -0.000185295  -3.207685e-08  0.0001173023
##                        Melanocarpus   Mycothermus  Subramaniula     Thielavia
## (Intercept)            4.888858e-05  3.362217e-06  6.455786e-07  7.010487e-06
## format_ITS_L6$Group11  7.989274e-05  4.151041e-06 -5.763701e-07 -8.136151e-06
## format_ITS_L6$Group12 -3.106039e-05 -2.170019e-06 -5.763701e-07 -1.153523e-05
## format_ITS_L6$Group13 -5.462034e-05 -2.170019e-06  4.458885e-07 -1.153523e-05
## dph                    4.396882e-07 -6.274729e-08 -3.642555e-09  2.381446e-07
##                           Zopfiella unidentified.32 Endophragmiella
## (Intercept)            3.707802e-04    4.260745e-04    1.043828e-05
## format_ITS_L6$Group11  3.636637e-04    2.306298e-04   -3.054058e-06
## format_ITS_L6$Group12 -2.243614e-04   -3.623308e-04   -5.223699e-06
## format_ITS_L6$Group13 -1.930573e-04   -5.663940e-05    8.488012e-06
## dph                    6.042712e-06    2.087354e-06   -2.744515e-07
##                              X__.51    Cercophora  Cladorrhinum     Podospora
## (Intercept)            1.133300e-04  1.093895e-04  4.244439e-05  3.407975e-03
## format_ITS_L6$Group11  1.414188e-04  1.492727e-04  9.985102e-05  1.481985e-03
## format_ITS_L6$Group12 -1.274609e-04 -1.755019e-04 -6.416702e-05 -2.374855e-03
## format_ITS_L6$Group13 -2.034475e-05 -6.443633e-05 -6.367753e-05 -1.146994e-03
## dph                    9.449465e-07  5.206860e-06  2.390393e-06  5.625986e-05
##                       Schizothecium unidentified.33    Neurospora      Sordaria
## (Intercept)            4.562570e-03    1.772396e-05  4.809831e-05  7.118641e-05
## format_ITS_L6$Group11  3.186290e-03   -3.053556e-05 -1.883456e-05 -8.537162e-05
## format_ITS_L6$Group12 -5.038729e-03   -4.559127e-05 -1.817371e-05 -9.240202e-05
## format_ITS_L6$Group13 -1.892977e-03    5.713071e-05 -1.394722e-05  4.767413e-05
## dph                    4.106406e-05    1.466701e-06 -1.540197e-06  2.802289e-06
##                       Ramophialophora    Remersonia Staphylotrichum
## (Intercept)              1.890386e-05  1.814720e-05    2.222145e-05
## format_ITS_L6$Group11   -3.210184e-06  1.473619e-06   -1.195211e-06
## format_ITS_L6$Group12   -1.832926e-05 -2.613643e-05   -1.375380e-05
## format_ITS_L6$Group13    2.854313e-05 -2.106820e-05   -1.375380e-05
## dph                     -3.024215e-08  6.266653e-07   -4.456659e-07
##                       unidentified.34 Pleurophragmium   Xylomelasma
## (Intercept)              7.338536e-05    5.178092e-07  1.974334e-06
## format_ITS_L6$Group11    9.553486e-05   -1.215095e-06 -2.063414e-06
## format_ITS_L6$Group12   -2.339289e-05   -1.215095e-06 -2.063414e-06
## format_ITS_L6$Group13   -3.887098e-05   -1.215095e-06 -2.063414e-06
## dph                     -1.634873e-06    3.669925e-08  4.688423e-09
##                       Phaeoacremonium    Nigrospora        X__.52    Arthrinium
## (Intercept)              2.122172e-07  5.765961e-04  2.196603e-06  1.824796e-06
## format_ITS_L6$Group11   -1.004946e-06  9.220522e-05 -1.467334e-06  3.706135e-06
## format_ITS_L6$Group12    2.579077e-06 -2.464293e-04 -1.467334e-06 -7.832312e-07
## format_ITS_L6$Group13   -1.004946e-06  4.379297e-04 -1.467334e-06 -5.787911e-06
## dph                      4.172259e-08 -1.287038e-05 -3.838260e-08  2.085850e-07
##                         Coniocessia        X__.53      Diatrype     Eutypella
## (Intercept)            6.759259e-06  1.466375e-06 -1.071753e-05  9.250381e-05
## format_ITS_L6$Group11 -5.723128e-05 -5.385298e-07 -2.016522e-05  7.753180e-05
## format_ITS_L6$Group12 -6.551831e-05 -5.385298e-07 -1.767434e-05 -2.471373e-05
## format_ITS_L6$Group13  4.597748e-05 -5.385298e-07  5.800478e-05 -2.361181e-05
## dph                    3.092582e-06 -4.883394e-08  1.625408e-06 -3.080608e-06
##                       Monosporascus Monographella      Idriella  Microdochium
## (Intercept)           -2.582017e-04 -4.042162e-08  2.301022e-06  2.604221e-04
## format_ITS_L6$Group11  7.903639e-04 -2.959836e-08 -3.064091e-06 -9.295831e-06
## format_ITS_L6$Group12 -2.787700e-04 -8.819574e-07 -3.064091e-06 -1.393259e-04
## format_ITS_L6$Group13 -2.526952e-04  8.069916e-07 -2.308509e-06  3.379105e-05
## dph                    2.959277e-05  4.854626e-08  4.016153e-08 -2.553433e-06
##                       unidentified.35        X__.54    Ascotricha Coniolariella
## (Intercept)              8.361927e-06  1.188653e-05  3.463361e-06  2.410006e-05
## format_ITS_L6$Group11   -6.581503e-06  1.919912e-05 -3.321398e-06 -1.845606e-05
## format_ITS_L6$Group12    5.192616e-06 -2.152697e-05 -3.321398e-06  1.030328e-05
## format_ITS_L6$Group13   -4.102049e-06 -1.441991e-05 -3.321398e-06 -2.855173e-06
## dph                     -9.370650e-08  5.073917e-07 -7.471697e-09 -2.970523e-07
##                           Hypoxylon       Poronia    Rosellinia       Xylaria
## (Intercept)            2.733943e-06  4.143292e-07  3.259380e-05  3.707255e-04
## format_ITS_L6$Group11 -1.004047e-06 -1.701021e-07 -4.934336e-05 -1.325743e-04
## format_ITS_L6$Group12  1.315197e-06 -1.701021e-07 -2.872471e-05 -1.601698e-04
## format_ITS_L6$Group13 -1.004047e-06 -1.701021e-07 -4.934336e-05 -8.393743e-05
## dph                   -9.104712e-08 -1.285406e-08  8.815558e-07  8.043280e-06
##                         Zygosporium      Fusidium    Hansfordia   Neoidriella
## (Intercept)            1.995304e-06  1.088210e-04  2.235712e-05  1.005414e-04
## format_ITS_L6$Group11 -1.374577e-06  5.131820e-07 -1.920659e-05  9.972063e-05
## format_ITS_L6$Group12 -1.374577e-06 -6.824284e-05 -1.420619e-05 -3.382243e-05
## format_ITS_L6$Group13  4.123732e-06  6.519649e-06 -1.630226e-05 -4.192017e-05
## dph                   -3.266985e-08 -1.763045e-06 -1.658173e-07 -3.054920e-06
##                       Phialemoniopsis unidentified.36 unidentified.37
## (Intercept)              3.279787e-04    4.603247e-07    2.735558e-05
## format_ITS_L6$Group11    2.842391e-04   -1.996954e-07   -2.380740e-05
## format_ITS_L6$Group12   -1.527471e-04   -1.996954e-07    4.192175e-05
## format_ITS_L6$Group13    5.597099e-06   -1.996954e-07   -1.447299e-05
## dph                     -7.147569e-06   -1.371733e-08   -1.867460e-07
##                       Symbiotaphrina  Basidiobolus        X__.55        X__.56
## (Intercept)             2.378507e-07  1.226086e-06  0.0092522160  1.632232e-04
## format_ITS_L6$Group11  -8.061292e-06 -1.031273e-06 -0.0050601651 -1.190499e-04
## format_ITS_L6$Group12  -8.061292e-06 -1.031273e-06  0.0226331360 -7.021300e-05
## format_ITS_L6$Group13  -4.841174e-06  7.021220e-07 -0.0088174087 -5.090701e-05
## dph                     4.117601e-07 -1.025331e-08  0.0002166101 -9.262008e-07
##                              X__.57        X__.58      Agaricus      Coprinus
## (Intercept)            8.411719e-05  1.167463e-05  1.756110e-05  1.093230e-04
## format_ITS_L6$Group11  1.811379e-04  6.336349e-06  5.579781e-06  1.047278e-04
## format_ITS_L6$Group12 -9.030018e-05 -1.304305e-05 -6.342436e-06 -4.014915e-05
## format_ITS_L6$Group13 -1.451090e-04 -6.079265e-06 -6.243991e-06 -4.014915e-05
## dph                    4.638596e-06  7.202205e-08 -4.615848e-07 -3.640729e-06
##                       Melanophyllum     Tulostoma       Amanita      Conocybe
## (Intercept)            6.185807e-07  1.403130e-05  7.219419e-06  1.946652e-05
## format_ITS_L6$Group11 -9.686730e-07 -1.647384e-05 -4.017466e-06 -1.310671e-05
## format_ITS_L6$Group12 -9.686730e-07 -1.401224e-05  3.075839e-06 -1.355974e-05
## format_ITS_L6$Group13 -9.686730e-07  1.582040e-05  2.018960e-06 -1.355974e-05
## dph                    1.842591e-08  1.285548e-07 -1.685239e-07 -3.108829e-07
##                           Panaeolus   Cortinarius    Gymnopilus    Crepidotus
## (Intercept)            7.961248e-06  1.144401e-05  8.796540e-06  9.924351e-05
## format_ITS_L6$Group11 -2.923789e-06 -5.186692e-06 -3.230552e-06  2.812888e-04
## format_ITS_L6$Group12 -2.923789e-06 -6.720626e-07  3.542883e-06 -1.201004e-04
## format_ITS_L6$Group13 -2.923789e-06  1.104545e-05 -1.099181e-06 -1.171736e-04
## dph                   -2.651295e-07 -3.293325e-07 -2.929468e-07  1.205687e-06
##                            Simocybe      Entoloma        X__.59      Naucoria
## (Intercept)            2.585187e-07  6.242994e-05  9.803944e-07  1.567807e-06
## format_ITS_L6$Group11 -1.866035e-06  1.988793e-05 -6.860638e-06 -1.060340e-06
## format_ITS_L6$Group12 -1.866035e-06 -3.177032e-05 -4.399717e-06  2.430305e-06
## format_ITS_L6$Group13 -1.866035e-06 -4.565982e-05  1.812099e-05 -3.096261e-07
## dph                    8.460611e-08  5.476898e-07  3.094865e-07 -2.670881e-08
##                              X__.60       Bovista      Calvatia    Lycoperdon
## (Intercept)           -7.106451e-07  2.181699e-06  9.403196e-05  2.784822e-05
## format_ITS_L6$Group11 -1.337091e-06 -4.980860e-06 -1.534449e-04 -2.347899e-05
## format_ITS_L6$Group12 -1.337091e-06 -4.980860e-06 -1.965894e-04 -1.623118e-05
## format_ITS_L6$Group13 -3.148320e-07  7.099380e-06 -6.882243e-05  3.003451e-05
## dph                    1.077756e-07  1.473243e-07  5.584630e-06 -1.478832e-07
##                            Calocybe    Lyophyllum   Mycenastrum      Gymnopus
## (Intercept)            5.192304e-05  4.297056e-05  6.335393e-06  3.017316e-05
## format_ITS_L6$Group11 -3.411263e-05 -1.629656e-05  1.819501e-05 -1.130990e-05
## format_ITS_L6$Group12 -3.484953e-05  2.799847e-06 -7.693546e-06  1.890621e-05
## format_ITS_L6$Group13  5.341636e-05 -2.403044e-06 -7.693546e-06 -2.932897e-06
## dph                   -8.986059e-07 -1.403894e-06  7.148173e-08 -9.928033e-07
##                           Mycetinis Rhodocollybia Cylindrobasidium
## (Intercept)            1.114318e-06  2.561345e-04     5.105649e-06
## format_ITS_L6$Group11 -7.108005e-06 -9.407407e-05    -1.875063e-06
## format_ITS_L6$Group12 -7.108005e-06  7.689985e-05    -1.242487e-07
## format_ITS_L6$Group13 -7.108005e-06 -1.309529e-05    -1.875063e-06
## dph                    3.154572e-07 -8.529495e-06    -1.700309e-07
##                          Flammulina   Strobilurus     Pleurotus   Volvariella
## (Intercept)            4.444850e-06  5.523006e-07  2.185300e-05  8.489942e-06
## format_ITS_L6$Group11  1.029972e-05 -2.617683e-06 -1.226869e-05 -3.268087e-06
## format_ITS_L6$Group12 -4.846658e-06 -5.598702e-07  1.092523e-05 -7.291711e-06
## format_ITS_L6$Group13 -4.846658e-06  5.487580e-06 -8.085565e-06 -7.291711e-06
## dph                    2.114777e-08  1.087043e-07 -5.044373e-07 -6.306477e-08
##                              X__.61   Coprinellus   Coprinopsis      Parasola
## (Intercept)            4.890255e-05  2.179598e-02  0.0007116263  1.830677e-04
## format_ITS_L6$Group11  6.844119e-05  6.193153e-03  0.0006179368  2.429601e-05
## format_ITS_L6$Group12 -3.270739e-05 -1.917410e-02 -0.0003848888 -1.636087e-04
## format_ITS_L6$Group13 -3.270739e-05 -1.379848e-02 -0.0003728245 -1.320608e-05
## dph                   -8.523771e-07 -3.462238e-05 -0.0000112809 -3.666915e-07
##                         Psathyrella Aphanobasidium   Radulomyces Schizophyllum
## (Intercept)            7.728601e-04   1.123021e-05  8.701233e-06  9.761631e-05
## format_ITS_L6$Group11  8.536401e-05  -6.734412e-06  1.898914e-06 -5.901367e-05
## format_ITS_L6$Group12 -1.722479e-04  -1.479936e-06  6.069073e-06 -1.282651e-05
## format_ITS_L6$Group13 -1.601177e-04   1.494876e-05 -4.294847e-06  1.190325e-04
## dph                   -2.296406e-05  -2.366211e-07 -2.319150e-07 -2.031718e-06
##                              X__.62 unidentified.38     Hypholoma Kuehneromyces
## (Intercept)            1.052625e-08    4.359250e-06  1.531023e-04  2.621022e-05
## format_ITS_L6$Group11 -1.560413e-07    7.232795e-06 -4.439429e-05 -1.176370e-05
## format_ITS_L6$Group12  3.421354e-07   -3.393294e-06  4.971276e-05  2.678931e-05
## format_ITS_L6$Group13 -1.560413e-07   -3.126618e-06  4.032058e-05 -4.448328e-06
## dph                    7.658688e-09   -5.083981e-08 -3.994043e-06 -7.603432e-07
##                            Pholiota       Tubaria     Baeospora     Clitocybe
## (Intercept)            3.167397e-05  2.028586e-06  2.236850e-04  2.444578e-04
## format_ITS_L6$Group11 -1.787463e-05 -7.903771e-07  6.837206e-05 -1.002763e-04
## format_ITS_L6$Group12  2.151106e-05 -7.903771e-07  1.693836e-05  8.524596e-05
## format_ITS_L6$Group13  1.423821e-05  9.306451e-07 -2.661495e-05  2.560099e-05
## dph                   -7.262811e-07 -6.516888e-08 -7.118004e-06 -7.385735e-06
##                            Collybia    Hemimycena       Lepista     Leucocybe
## (Intercept)            7.901820e-06  1.554895e-05  5.128635e-05  1.239284e-05
## format_ITS_L6$Group11 -4.039400e-06 -5.496098e-06 -1.883504e-05 -4.551301e-06
## format_ITS_L6$Group12  3.511258e-06  1.766197e-06  1.991735e-05  1.343530e-05
## format_ITS_L6$Group13  4.567541e-06 -5.710392e-06 -7.930298e-06 -4.332699e-06
## dph                   -2.032853e-07 -5.178190e-07 -1.707964e-06 -4.127125e-07
##                        Megacollybia   Melanoleuca        Mycena      Panellus
## (Intercept)           -4.569191e-06  1.054089e-06  3.919895e-04  1.461364e-05
## format_ITS_L6$Group11 -5.859493e-06 -8.839755e-07 -1.348076e-04 -1.647806e-05
## format_ITS_L6$Group12  1.516518e-06 -8.839755e-07  1.051523e-04  1.166645e-05
## format_ITS_L6$Group13  1.020247e-05 -8.839755e-07  2.499237e-05  2.128966e-05
## dph                    5.488781e-07 -8.953346e-09 -1.271860e-05  9.812728e-08
##                         Paralepista Pseudoclitocybe    Tricholoma       Typhula
## (Intercept)            1.321090e-05    2.230019e-05  5.158086e-05  5.658669e-05
## format_ITS_L6$Group11 -4.851735e-06   -8.189800e-06 -1.894320e-05 -3.484346e-05
## format_ITS_L6$Group12  8.934016e-06   -2.987250e-06  3.217418e-05  1.106323e-05
## format_ITS_L6$Group13 -4.851735e-06   -8.189800e-06 -1.062242e-05 -2.659081e-05
## dph                   -4.399559e-07   -7.426519e-07 -1.717771e-06  1.909921e-06
##                       unidentified.39  Amyloxenasma     Amphinema       Athelia
## (Intercept)              1.532607e-06  1.693119e-05  4.012686e-05  4.006285e-05
## format_ITS_L6$Group11   -6.949643e-07 -7.463986e-06 -1.585515e-05 -1.763324e-05
## format_ITS_L6$Group12   -6.949643e-07  1.108620e-05  1.147490e-05  2.670198e-05
## format_ITS_L6$Group13   -6.949643e-07 -7.463986e-06  2.215450e-06  6.082319e-06
## dph                     -4.408644e-08 -4.982741e-07 -1.277458e-06 -1.180506e-06
##                         Auricularia     Oliveonia        Exidia       Imleria
## (Intercept)            8.601967e-05  8.478819e-04  9.522635e-06  1.668623e-05
## format_ITS_L6$Group11 -8.704923e-06  7.885658e-05 -1.421565e-05 -6.128059e-06
## format_ITS_L6$Group12  4.254377e-06 -1.073990e-03 -1.421565e-05  1.074770e-05
## format_ITS_L6$Group13 -2.821601e-05 -7.711652e-04  4.264696e-05 -3.012978e-06
## dph                   -2.093879e-06  2.243504e-05  2.470009e-07 -5.556930e-07
##                       Hydnomerulius Hygrophoropsis      Paxillus       Suillus
## (Intercept)            2.604408e-06   1.866450e-05  1.603219e-05  2.173381e-06
## format_ITS_L6$Group11 -2.443416e-06  -7.861564e-06 -1.171391e-05 -1.469902e-06
## format_ITS_L6$Group12  6.491167e-06   2.065163e-05 -6.965139e-06 -2.803572e-07
## format_ITS_L6$Group13 -1.604336e-06  -5.626404e-06  2.605227e-05  3.220161e-06
## dph                   -8.473271e-09  -5.685757e-07 -2.272776e-07 -3.702524e-08
##                              X__.63 Botryobasidium    Minimedusa    Sistotrema
## (Intercept)            1.807238e-05   9.029162e-05  3.754840e-04  3.578081e-04
## format_ITS_L6$Group11 -1.284438e-05  -4.372621e-05  4.746161e-04 -2.686525e-04
## format_ITS_L6$Group12 -1.896275e-05   5.085792e-06 -5.357699e-04  3.181371e-04
## format_ITS_L6$Group13 -1.002310e-05   7.425180e-06 -2.954475e-04 -3.901657e-04
## dph                    4.686178e-08  -2.450811e-06  1.197522e-05  6.356311e-06
##                       unidentified.40        X__.64 Thanatephorus
## (Intercept)              2.444092e-07  9.008725e-05  3.721237e-04
## format_ITS_L6$Group11   -1.764190e-06  9.806333e-05  4.409241e-04
## format_ITS_L6$Group12    2.337344e-06 -3.189379e-05 -6.758351e-04
## format_ITS_L6$Group13    1.191035e-06 -3.308477e-05 -5.004174e-04
## dph                      7.998846e-08 -3.000130e-06  1.853406e-05
##                       unidentified.41     Corticium   Limonomyces   Vuilleminia
## (Intercept)              5.801986e-06  2.589887e-05  6.533921e-06  1.802507e-05
## format_ITS_L6$Group11   -3.184258e-06 -3.350171e-05 -2.669434e-06 -7.977947e-06
## format_ITS_L6$Group12   -9.311177e-06 -3.605078e-05 -2.272919e-06 -7.977947e-06
## format_ITS_L6$Group13    2.265036e-05 -2.515870e-05  7.448038e-06  2.206506e-06
## dph                      2.291023e-07  5.343110e-07 -2.033941e-07 -5.287957e-07
##                            Geastrum    Fuscoporia Hymenochaetopsis
## (Intercept)            6.323172e-05  1.198457e-05     6.858274e-06
## format_ITS_L6$Group11 -1.011457e-05 -7.262679e-06    -2.518718e-06
## format_ITS_L6$Group12 -3.277341e-05  1.363269e-05     3.034763e-06
## format_ITS_L6$Group13  7.292753e-05  1.463562e-06    -2.518718e-06
## dph                   -1.603069e-06 -1.708784e-07    -2.283976e-07
##                       Peniophorella    Resinicium    Trichaptum        X__.65
## (Intercept)            5.126429e-05  1.013608e-04  1.508055e-05  1.210200e-04
## format_ITS_L6$Group11 -1.318316e-06 -6.070850e-05 -6.427184e-06 -5.379851e-05
## format_ITS_L6$Group12  8.343246e-06  8.600100e-06  2.833536e-06  3.299652e-05
## format_ITS_L6$Group13 -6.218945e-06  7.879986e-05 -3.909944e-06 -7.832921e-06
## dph                   -1.092231e-06 -2.139592e-06 -4.554403e-07 -3.537972e-06
##                       Alutaceodontia   Hyphodontia      Lyomyces      Oxyporus
## (Intercept)             4.374602e-05  2.238069e-04  1.096679e-04  2.303686e-05
## format_ITS_L6$Group11  -2.460322e-05 -8.695542e-05 -6.609682e-05 -8.460344e-06
## format_ITS_L6$Group12   2.155931e-06  7.448816e-05 -4.338199e-05  1.189232e-05
## format_ITS_L6$Group13   3.633297e-05  7.391939e-06 -6.710739e-05 -8.460344e-06
## dph                    -1.007516e-06 -7.202711e-06 -1.439883e-06 -7.671849e-07
##                          Schizopora       Xylodon  Tubulicrinis Gastrosporium
## (Intercept)            2.279391e-05  3.448409e-05  1.336248e-05  2.761513e-06
## format_ITS_L6$Group11 -1.144273e-05 -2.081694e-05 -4.907403e-06 -3.079137e-06
## format_ITS_L6$Group12  9.240718e-06  3.499097e-06 -1.346517e-06 -3.079137e-06
## format_ITS_L6$Group13  1.364474e-05  5.275922e-06  1.018740e-06 -7.455326e-07
## dph                   -5.974307e-07 -7.193240e-07 -4.450038e-07  1.671703e-08
##                             Lysurus        X__.66      Trametes unidentified.42
## (Intercept)            1.292552e-04  2.948052e-06  2.280813e-04    3.043081e-07
## format_ITS_L6$Group11  1.237722e-04 -1.993827e-06  8.502402e-05   -2.196551e-06
## format_ITS_L6$Group12 -4.869239e-05 -5.399392e-07 -4.822933e-05    5.960820e-07
## format_ITS_L6$Group13 -5.141478e-05  4.527593e-06 -8.370249e-05    3.797020e-06
## dph                   -4.082827e-06 -5.022235e-08 -6.356389e-06    9.959173e-08
##                            Antrodia  Cinereomyces    Fomitopsis    Piptoporus
## (Intercept)            1.579863e-05  2.400215e-06  2.799129e-04  4.637052e-06
## format_ITS_L6$Group11 -6.542001e-06 -9.390019e-07 -1.518036e-04 -5.600998e-06
## format_ITS_L6$Group12 -1.737037e-06  4.402877e-07 -1.971069e-05 -5.600998e-06
## format_ITS_L6$Group13 -5.455504e-06 -4.355538e-07  2.512074e-04  1.312424e-05
## dph                   -4.871910e-07 -7.690594e-08 -6.742596e-06  5.073401e-08
##                           Tyromyces        X__.67  Perenniporia    Hyphoderma
## (Intercept)            3.649667e-06  1.284942e-05  1.342633e-04  1.682012e-04
## format_ITS_L6$Group11 -1.340350e-06 -1.303482e-04  1.062198e-04  1.592710e-04
## format_ITS_L6$Group12  1.149353e-06 -6.882882e-05 -2.342528e-05 -8.122188e-05
## format_ITS_L6$Group13 -1.340350e-06  3.242901e-04 -5.122091e-05 -7.464432e-05
## dph                   -1.215430e-07  6.184146e-06 -4.305879e-06 -4.577859e-06
##                              X__.68 Climacocystis     Meripilus   Rigidoporus
## (Intercept)            8.111987e-06  5.186601e-06  6.963646e-06  2.847143e-05
## format_ITS_L6$Group11 -3.370513e-06 -1.252916e-05 -7.365079e-06 -1.611098e-04
## format_ITS_L6$Group12  1.011154e-05 -8.035320e-06 -7.274128e-06  1.560854e-05
## format_ITS_L6$Group13 -3.370513e-06  3.309363e-05 -7.365079e-06  2.771691e-04
## dph                   -2.495512e-07  3.864502e-07  2.112807e-08  6.980965e-06
##                       unidentified.43   Bjerkandera  Ceraceomyces     Ceriporia
## (Intercept)              3.576234e-05  1.125808e-04  1.662435e-05  3.062638e-07
## format_ITS_L6$Group11   -1.723836e-05 -6.520886e-06 -6.105336e-06 -6.233010e-06
## format_ITS_L6$Group12    4.184300e-07 -2.783577e-05 -1.771817e-06 -5.487131e-06
## format_ITS_L6$Group13   -2.838499e-06  8.245771e-05  1.171074e-05  1.795315e-05
## dph                     -9.636678e-07 -3.287149e-06 -5.536325e-07  3.119340e-07
##                         Hapalopilus         Irpex      Mycoacia    Neofavolus
## (Intercept)            2.061366e-06  2.257237e-03  1.288192e-04  1.693323e-05
## format_ITS_L6$Group11 -7.570421e-07  2.381506e-03  1.419276e-04 -6.218770e-06
## format_ITS_L6$Group12  9.984174e-07 -7.968375e-04 -4.730919e-05 -6.218770e-06
## format_ITS_L6$Group13 -7.570421e-07 -7.812910e-04 -4.730919e-05  1.647452e-05
## dph                   -6.864865e-08 -7.491567e-05 -4.290002e-06 -5.639187e-07
##                       Phanerochaete       Phlebia   Phlebiopsis   Porostereum
## (Intercept)            1.663595e-05  1.153616e-04  3.591299e-06  8.751994e-05
## format_ITS_L6$Group11 -8.503844e-06 -5.461196e-05 -1.704446e-06  4.060062e-05
## format_ITS_L6$Group12  3.573855e-06  2.708671e-05  1.440561e-06 -2.366603e-05
## format_ITS_L6$Group13  5.600445e-06  4.329931e-05  2.162462e-07 -1.454460e-05
## dph                   -4.280054e-07 -3.197347e-06 -9.930804e-08 -2.914633e-06
##                         Scopuloides  Hypochnicium         Fomes      Lentinus
## (Intercept)            1.331480e-05  1.541110e-05  4.903955e-05  1.248261e-05
## format_ITS_L6$Group11 -4.889893e-06 -7.963449e-06 -1.800990e-05 -5.103773e-06
## format_ITS_L6$Group12 -4.889893e-06  9.289225e-06 -1.800990e-05 -5.103773e-06
## format_ITS_L6$Group13  1.224545e-05  4.420330e-07  4.234931e-05  1.531132e-05
## dph                   -4.434160e-07 -3.919817e-07 -1.633139e-06 -3.883599e-07
##                            Rhodonia  Xenasmatella Heterobasidion        X__.69
## (Intercept)            3.368842e-07  1.174939e-05   1.117879e-05  9.907947e-06
## format_ITS_L6$Group11 -2.690379e-06 -4.801695e-06  -5.800572e-06 -3.638719e-06
## format_ITS_L6$Group12 -2.690379e-06  1.424113e-05   1.485204e-05 -2.196734e-06
## format_ITS_L6$Group13  7.857185e-06 -4.637743e-06  -3.861922e-06 -3.638719e-06
## dph                    1.238682e-07 -3.656681e-07  -2.830643e-07 -3.299594e-07
##                          Peniophora  Amylostereum       Stereum        X__.70
## (Intercept)            2.373012e-05  9.092041e-06  9.128335e-06  9.455181e-06
## format_ITS_L6$Group11  2.035482e-05 -3.339075e-06 -3.609106e-06 -4.400594e-06
## format_ITS_L6$Group12 -2.330503e-05 -3.339075e-06  2.184892e-06  1.050526e-05
## format_ITS_L6$Group13  1.022551e-06 -3.339075e-06  3.639401e-06 -1.704075e-06
## dph                    5.329606e-08 -3.027877e-07 -2.904857e-07 -2.660309e-07
##                          Tomentella Tomentellopsis   Trechispora
## (Intercept)           -9.458806e-07   5.615313e-06  2.225852e-05
## format_ITS_L6$Group11  1.038152e-05  -3.682395e-05 -1.083687e-05
## format_ITS_L6$Group12 -1.630043e-06  -3.741940e-05  7.948759e-06
## format_ITS_L6$Group13 -4.375737e-06  -3.741940e-05  1.192375e-05
## dph                    2.800851e-07   1.673899e-06 -6.011394e-07
##                       Sistotremastrum unidentified.44 unidentified.45
## (Intercept)              4.743231e-05    4.802806e-06    2.901744e-04
## format_ITS_L6$Group11   -1.269673e-06   -1.763843e-06   -7.255329e-05
## format_ITS_L6$Group12    9.375473e-06    5.127576e-06   -3.542872e-04
## format_ITS_L6$Group13    4.836490e-06   -1.599891e-06    1.043267e-04
## dph                     -1.104715e-06   -1.599454e-07    4.634691e-06
##                       Kurtzmanomyces Cystobasidium    Occultifur Symmetrospora
## (Intercept)             4.934722e-05  6.304515e-04  3.449415e-05  6.200364e-05
## format_ITS_L6$Group11   3.549495e-05  6.162994e-04 -5.633770e-05  7.267784e-05
## format_ITS_L6$Group12  -8.344271e-05 -2.388738e-04 -1.571239e-05 -2.586600e-05
## format_ITS_L6$Group13   6.094763e-06 -2.655075e-04  1.198765e-04 -2.726458e-05
## dph                     1.848424e-06 -1.409002e-05  1.149661e-06 -1.597296e-06
##                          Sakaguchia  Tilletiopsis         Meira   Exobasidium
## (Intercept)            4.065368e-05  8.980738e-06  5.967569e-05 -3.485046e-06
## format_ITS_L6$Group11  4.634693e-05 -1.169422e-05  9.061318e-06 -8.277628e-05
## format_ITS_L6$Group12 -3.656599e-05 -1.108464e-05 -2.858021e-05 -2.206295e-04
## format_ITS_L6$Group13 -1.652680e-05 -5.491463e-06  3.895680e-05 -4.045560e-04
## dph                   -2.151418e-07  1.428147e-07 -1.636604e-06  3.312996e-05
##                           Golubevia   Quambalaria     Robbauera      Tilletia
## (Intercept)            2.204086e-05  1.486506e-06  1.060909e-03  1.921934e-06
## format_ITS_L6$Group11 -9.093010e-06 -1.838451e-06  8.590906e-05 -2.376971e-06
## format_ITS_L6$Group12 -5.867521e-06  9.820381e-07  2.348189e-04 -2.376971e-06
## format_ITS_L6$Group13  2.095871e-05  2.694864e-06  2.535252e-05  7.130913e-06
## dph                   -6.814656e-07  1.852344e-08 -3.533029e-05  2.394933e-08
##                        Basidioascus Geminibasidium    Malassezia
## (Intercept)            6.918059e-06   4.534459e-06  0.0052345727
## format_ITS_L6$Group11  9.835284e-06   5.351556e-06  0.0147223631
## format_ITS_L6$Group12 -6.710813e-06  -3.406521e-06 -0.0087041995
## format_ITS_L6$Group13 -6.710813e-06  -3.406521e-06 -0.0058632526
## dph                   -1.090770e-08  -5.936516e-08  0.0003438867
##                       unidentified.46 Ustilentyloma   Colacogloea Curvibasidium
## (Intercept)              4.133132e-04  4.748308e-06  2.216960e-06  1.066298e-07
## format_ITS_L6$Group11    2.150047e-03 -5.746162e-06 -1.923904e-06 -7.696729e-07
## format_ITS_L6$Group12   -9.071723e-04 -5.746162e-06  3.196883e-06  8.494515e-07
## format_ITS_L6$Group13   -6.602318e-04  1.066570e-06  6.509247e-07  6.898944e-07
## dph                      2.761939e-05  5.251860e-08 -1.542404e-08  3.489701e-08
##                       Rhodosporidiobolus   Rhodotorula Sporobolomyces
## (Intercept)                 6.090793e-06  7.781219e-03   1.925356e-04
## format_ITS_L6$Group11      -2.739650e-06  2.470110e-03   6.020868e-05
## format_ITS_L6$Group12       8.218950e-06  2.218902e-06   2.340499e-06
## format_ITS_L6$Group13      -2.739650e-06 -2.838688e-03  -4.088122e-05
## dph                        -1.763760e-07 -1.586962e-04  -5.475488e-06
##                       unidentified.47    Moniliella    Melampsora      Puccinia
## (Intercept)              3.337604e-07  6.366516e-06  7.073125e-06  1.506758e-05
## format_ITS_L6$Group11   -2.409143e-06  2.191688e-05 -5.740987e-06 -5.533608e-06
## format_ITS_L6$Group12   -7.040775e-08 -1.240357e-05 -5.740987e-06 -3.392044e-06
## format_ITS_L6$Group13    4.888694e-06  5.790787e-06  1.252641e-05 -3.966363e-06
## dph                      1.092307e-07  7.281118e-07 -7.011251e-08 -5.017881e-07
##                       Cystofilobasidium   Itersonilia        Mrakia
## (Intercept)                1.236703e-04  5.757062e-05  6.639261e-04
## format_ITS_L6$Group11      6.775206e-05 -2.114296e-05 -1.390663e-04
## format_ITS_L6$Group12     -1.560322e-05  9.312569e-06  5.464036e-04
## format_ITS_L6$Group13      2.678074e-06  2.412688e-05 -2.083125e-04
## dph                       -3.588251e-06 -1.917245e-06 -2.186772e-05
##                            Tausonia  Filobasidium    Naganishia Solicoccozyma
## (Intercept)            2.215516e-04  1.879566e-03  0.0071864935  1.485968e-04
## format_ITS_L6$Group11  4.376776e-04  1.381772e-03  0.0065755575  4.324493e-05
## format_ITS_L6$Group12 -2.013381e-04  1.514612e-03 -0.0024529309 -2.109245e-04
## format_ITS_L6$Group13 -2.508542e-04 -1.312153e-03 -0.0025303537 -2.675612e-05
## dph                    3.981874e-06  8.282918e-05 -0.0002336469  4.448519e-06
##                             Bullera   Genolevuria     Dioszegia     Hannaella
## (Intercept)            3.111591e-06 -2.336723e-05  1.612222e-05  2.227043e-04
## format_ITS_L6$Group11 -1.142740e-06  4.169841e-05  1.761492e-05 -1.023062e-04
## format_ITS_L6$Group12 -1.142740e-06  3.879379e-06 -1.810033e-05 -1.380050e-04
## format_ITS_L6$Group13  3.428219e-06 -2.278889e-05 -1.028735e-05 -1.866719e-04
## dph                   -1.036237e-07  2.429270e-06  1.041112e-07  1.855664e-06
##                       Vishniacozyma  Papiliotrema  Bulleromyces  Cryptococcus
## (Intercept)            2.309500e-04  2.083758e-04 -1.132446e-05 -3.145312e-05
## format_ITS_L6$Group11  2.019929e-04 -2.240149e-05 -1.551576e-05  2.630848e-04
## format_ITS_L6$Group12 -1.231162e-04  1.407947e-05 -1.176451e-05 -1.179806e-04
## format_ITS_L6$Group13 -1.169242e-04  1.465365e-04  3.031198e-05 -8.763339e-05
## dph                    3.800033e-06 -1.756779e-06  1.468102e-06  7.941453e-06
##                           Saitozyma   Apiotrichum Cutaneotrichosporon
## (Intercept)           -1.784032e-05  4.698844e-05        9.746467e-04
## format_ITS_L6$Group11 -1.803350e-05  2.060403e-05        1.014198e-03
## format_ITS_L6$Group12 -1.803350e-05  1.390921e-05       -3.682911e-04
## format_ITS_L6$Group13 -1.803350e-05 -1.725662e-05       -2.441257e-04
## dph                    1.888096e-06 -1.564832e-06       -1.973974e-05
##                       Trichosporon    Thecaphora     Urocystis        X__.71
## (Intercept)             0.16593514  1.650969e-06  9.502330e-06  5.834586e-07
## format_ITS_L6$Group11   0.01772384 -2.482385e-06 -9.165899e-06 -3.303131e-07
## format_ITS_L6$Group12  -0.02465745 -2.482385e-06 -7.136567e-06 -2.473199e-08
## format_ITS_L6$Group13   0.03565671 -2.304601e-06 -1.913693e-06  6.853582e-07
## dph                    -0.00435752  4.375872e-08  7.548119e-08 -1.332345e-08
##                        Moesziomyces   Sporisorium Tranzscheliella      Ustilago
## (Intercept)            7.139586e-05  1.268737e-04    3.088989e-05  2.854892e-04
## format_ITS_L6$Group11  6.466516e-05  2.193549e-05    6.841693e-06 -1.409158e-05
## format_ITS_L6$Group12 -1.354497e-05  3.544129e-05   -1.747661e-05 -7.216945e-05
## format_ITS_L6$Group13  1.013609e-05 -2.209650e-06   -2.267121e-05  3.482989e-05
## dph                   -1.987067e-07 -3.320991e-06    1.114773e-08 -6.930517e-06
##                            Wallemia        X__.72 Phlyctochytrium Rhizophlyctis
## (Intercept)            0.0038532184 -0.0001417466    1.031499e-05 -2.267638e-07
## format_ITS_L6$Group11  0.0012333854  0.0007173083    3.421571e-05  1.590406e-05
## format_ITS_L6$Group12 -0.0007720776 -0.0002695237   -1.497699e-05 -1.313041e-05
## format_ITS_L6$Group13  0.0007924633 -0.0002485555   -1.497699e-05 -1.344071e-05
## dph                   -0.0001006684  0.0000219830    2.453689e-07  7.286979e-07
##                        Powellomyces Spizellomyces unidentified.48        X__.73
## (Intercept)            2.717180e-07  6.496861e-05    1.687609e-04  1.238727e-03
## format_ITS_L6$Group11 -5.260943e-07  7.435199e-05   -8.526920e-05  4.343496e-04
## format_ITS_L6$Group12 -1.455940e-06 -3.947045e-05   -3.089075e-05 -1.228561e-03
## format_ITS_L6$Group13 -3.366766e-08 -4.601753e-05   -2.914215e-05 -1.094706e-03
## dph                    6.232750e-08 -4.631177e-07    2.821033e-06  2.210737e-05
##                           Dominikia        Glomus   Rhizophagus   Septoglomus
## (Intercept)            5.407234e-05  7.516137e-05 -3.303918e-06  5.479488e-05
## format_ITS_L6$Group11 -3.625668e-06  6.318136e-05  8.190663e-05  4.727528e-05
## format_ITS_L6$Group12 -5.330057e-05 -4.258593e-05 -6.038232e-05 -8.267943e-05
## format_ITS_L6$Group13 -5.973784e-05 -5.807486e-05 -4.625540e-05 -6.618198e-05
## dph                    5.976617e-07 -8.276440e-07  3.740869e-06  1.467608e-06
##                         Mortierella unidentified.49 unidentified.50
## (Intercept)            0.0117884692    2.053273e-05    1.063208e-06
## format_ITS_L6$Group11  0.0038459655    6.668518e-05   -1.443841e-06
## format_ITS_L6$Group12 -0.0091349205   -2.795468e-05   -1.443841e-06
## format_ITS_L6$Group13 -0.0086395767   -2.015582e-05    4.331523e-06
## dph                    0.0001863713    3.906290e-07    2.003330e-08
##                         Lichtheimia        X__.74   Actinomucor         Mucor
## (Intercept)            3.648517e-06  4.337236e-04  7.516326e-05  0.0094814261
## format_ITS_L6$Group11 -4.493834e-06 -1.392149e-04 -1.224557e-04 -0.0043541083
## format_ITS_L6$Group12 -3.717177e-06 -1.741022e-04 -4.554382e-04 -0.0030593369
## format_ITS_L6$Group13 -2.793486e-06  4.381511e-04  1.091160e-03  0.0107837244
## dph                    4.449034e-08 -1.158949e-05  2.687766e-05 -0.0002297722
##                            Rhizopus      Olpidium unidentified.51
## (Intercept)            9.047841e-04  2.448512e-06    1.118001e-06
## format_ITS_L6$Group11 -3.017267e-04 -7.940582e-07   -5.043022e-07
## format_ITS_L6$Group12 -7.901457e-05 -9.241943e-06   -5.043022e-07
## format_ITS_L6$Group13  6.350882e-04 -9.241943e-06   -5.043022e-07
## dph                   -2.129517e-05  3.575490e-07   -3.229992e-08
##                       unidentified.52 unidentified.53
## (Intercept)             -3.781709e-06    2.059323e-05
## format_ITS_L6$Group11   -2.537763e-05   -1.626282e-05
## format_ITS_L6$Group12   -2.684988e-05   -2.072755e-05
## format_ITS_L6$Group13   -2.684988e-05   -7.928688e-06
## dph                      1.612189e-06    7.069349e-09
## 
## $coef.sites
##                            D01E01C      D01E01D      D01E01I      D01E01J
## (Intercept)            0.690749770  0.683884132  0.672241744  0.648518719
## format_ITS_L6$Group11  0.008205236  0.003422069  0.045274411  0.072882379
## format_ITS_L6$Group12  0.037326309  0.011296273  0.012325389  0.012452256
## format_ITS_L6$Group13 -0.008302508 -0.022155435 -0.061450425 -0.073577188
## dph                    0.001797301  0.002188213  0.002623643  0.003798274
##                            D01E02C      D01E02D      D01E02I      D01E02J
## (Intercept)            0.625101447  0.818379660  0.712199460  0.613064015
## format_ITS_L6$Group11  0.056758128 -0.006991592  0.049778923  0.073029070
## format_ITS_L6$Group12  0.045664689  0.010277908  0.002903635  0.014968756
## format_ITS_L6$Group13 -0.046596029  0.004479269 -0.061312323 -0.074692319
## dph                    0.003934575  0.001694343  0.002706884  0.004275007
##                            D01E03C      D01E03D      D01E03I      D01E03J
## (Intercept)            0.686149592  0.797087119  0.659800257  0.652553512
## format_ITS_L6$Group11  0.045546498 -0.023058742  0.076444487  0.076696012
## format_ITS_L6$Group12  0.033911261  0.023754909  0.008721196  0.012102549
## format_ITS_L6$Group13 -0.036082561  0.001223870 -0.077376097 -0.075978561
## dph                    0.002808614  0.001712153  0.003820650  0.004130912
##                            D01E04C      D01E04D      D01E04I       D01E04J
## (Intercept)            0.701756749  0.666794352  0.715803766  0.7062181774
## format_ITS_L6$Group11  0.066814928  0.050091860  0.071735876  0.0796302680
## format_ITS_L6$Group12  0.020579993  0.028207281  0.009777376  0.0009726248
## format_ITS_L6$Group13 -0.050085526 -0.051933332 -0.065013251 -0.0633790494
## dph                    0.003373713  0.003438028  0.003192443  0.0032030325
##                            D01E05C       D01E05D      D01E05I      D01E05J
## (Intercept)            0.676059190  0.8409657166  0.711758010  0.665117403
## format_ITS_L6$Group11  0.053276546 -0.0135436090  0.071787959  0.062830359
## format_ITS_L6$Group12  0.034924924  0.0049262478  0.013294257  0.005316200
## format_ITS_L6$Group13 -0.049134633  0.0027431256 -0.062765760 -0.069130883
## dph                    0.002808685  0.0002056162  0.003212577  0.003397677
##                            D01E06C      D01E06D       D01E06I      D01E06J
## (Intercept)            0.731386190  0.734069596  6.784927e-01  0.656121785
## format_ITS_L6$Group11  0.135175682  0.006788727  6.837474e-02  0.069687369
## format_ITS_L6$Group12 -0.161524766 -0.017948082 -4.884151e-05  0.002729806
## format_ITS_L6$Group13 -0.053851013 -0.010258883 -7.344350e-02 -0.073723748
## dph                   -0.001866066  0.001651109  3.041710e-03  0.003381975
##                            D01E07C      D01E07D      D01E07I       D01E07J
## (Intercept)            0.735322369  0.681758205  0.660087257  0.7019852717
## format_ITS_L6$Group11  0.058143359  0.004860607  0.077396539  0.0496014311
## format_ITS_L6$Group12 -0.002588071  0.027115319  0.007940545 -0.0004367136
## format_ITS_L6$Group13 -0.037234075 -0.029669181 -0.076970886 -0.0485912247
## dph                    0.001884841  0.003671020  0.004106550  0.0033988897
##                            D01E08C       D01E08D     D01E08I      D01E08J
## (Intercept)            0.653407050  0.7186816400  0.65439275  0.614489112
## format_ITS_L6$Group11  0.059333010 -0.0008112118  0.05810285  0.028161883
## format_ITS_L6$Group12  0.019943573  0.0042563733  0.01542911  0.029693750
## format_ITS_L6$Group13 -0.059612323 -0.0130540642 -0.06922207 -0.061313534
## dph                    0.003299699  0.0022666549  0.00310739  0.004754806
##                            D01E09C       D01E09D      D01E09I      D01E09J
## (Intercept)            0.758454479  0.8143209304  0.661741621  0.613848316
## format_ITS_L6$Group11  0.065933547 -0.0289108475  0.067313865  0.067095302
## format_ITS_L6$Group12  0.014006924  0.0229732083  0.010454944  0.015819833
## format_ITS_L6$Group13 -0.046729568  0.0115289460 -0.073052810 -0.073022292
## dph                    0.002446475  0.0009043027  0.003533469  0.004906644
##                            D01E10C      D01E10D      D01E10I       D01E10J
## (Intercept)            0.674330263  0.808178113  0.671875023  7.547293e-01
## format_ITS_L6$Group11  0.026824387 -0.024411603  0.067219017  1.797382e-02
## format_ITS_L6$Group12  0.039234859  0.014880567  0.012023492 -2.002765e-02
## format_ITS_L6$Group13 -0.024251058  0.004881454 -0.076481934 -2.348380e-02
## dph                    0.002940878  0.001807562  0.003472085  4.251286e-05
##                            D04E01C      D04E01D      D04E01I      D04E01J
## (Intercept)           0.5435293449  0.677899294  0.585304809  0.647991173
## format_ITS_L6$Group11 0.0054072328 -0.058630398  0.000165257  0.142600712
## format_ITS_L6$Group12 0.0940993750  0.083113713  0.064009446 -0.225647324
## format_ITS_L6$Group13 0.0196611808  0.073766455 -0.039252300 -0.015033552
## dph                   0.0007746741 -0.002596843  0.002702782 -0.005186521
##                             D04E02C      D04E02D       D04E02I      D04E02J
## (Intercept)            0.5612854108  0.621786984  0.7160004719  0.689678071
## format_ITS_L6$Group11 -0.0101682094 -0.055963569 -0.0209534417 -0.034996735
## format_ITS_L6$Group12  0.1068618988  0.090049593  0.0463293810  0.039537682
## format_ITS_L6$Group13  0.0451089581  0.049876204 -0.0041764855  0.058097056
## dph                   -0.0001885955 -0.001757243  0.0005294644 -0.003081745
##                            D04E03C       D04E03D      D04E03I      D04E03J
## (Intercept)            0.579164157  0.6808823311  0.612590544  0.693942418
## format_ITS_L6$Group11  0.006172663 -0.0110335107  0.069470977  0.139720870
## format_ITS_L6$Group12  0.081488660  0.0256297484 -0.066399699 -0.242248906
## format_ITS_L6$Group13  0.047177448 -0.0092403047 -0.040561174  0.007553690
## dph                   -0.001980906  0.0006348607 -0.002195905 -0.006703184
##                             D04E04C       D04E04D      D04E04I      D04E04J
## (Intercept)            0.5817649055  0.6102931642  0.616070642  0.637524447
## format_ITS_L6$Group11 -0.0294232186 -0.0426570600  0.028661161  0.145331649
## format_ITS_L6$Group12  0.1040479892  0.0906378495  0.010288365 -0.221845182
## format_ITS_L6$Group13  0.0575329811  0.0142292547 -0.060693450 -0.031544050
## dph                   -0.0007263261  0.0005468153  0.003283549 -0.003650649
##                            D04E05C      D04E05D      D04E05I      D04E05J
## (Intercept)            0.583721093  0.644825740  0.624874323  0.644135354
## format_ITS_L6$Group11  0.043320195 -0.040912960  0.092347239  0.147113084
## format_ITS_L6$Group12 -0.002977287  0.115916692 -0.115119752 -0.228611826
## format_ITS_L6$Group13  0.019192880  0.080141040 -0.048482340 -0.023501987
## dph                   -0.003489224 -0.002668026 -0.002624627 -0.004519135
##                             D04E06C       D04E06D      D04E06I      D04E06J
## (Intercept)            0.5582951936  0.5953085248  0.692423874  0.639274441
## format_ITS_L6$Group11 -0.0140328250 -0.0517390045  0.007836926  0.138794500
## format_ITS_L6$Group12  0.1017739195  0.0976939106  0.004100406 -0.217892813
## format_ITS_L6$Group13  0.0346862481  0.0279920416 -0.044661416 -0.023334859
## dph                    0.0005191524 -0.0002606546  0.003357156 -0.003868951
##                            D04E07C       D04E07D     D04E07I      D04E07J
## (Intercept)            0.596924636  0.7266089138  0.63467413  0.650066476
## format_ITS_L6$Group11 -0.012648809 -0.0422201714  0.04201289  0.133586248
## format_ITS_L6$Group12  0.109409658  0.0520135793  0.02246810 -0.215344039
## format_ITS_L6$Group13  0.063533683  0.0235299905 -0.08407274 -0.016546220
## dph                   -0.001773579 -0.0005658293  0.00485866 -0.004306699
##                            D04E08C       D04E08D      D04E08I       D04E08J
## (Intercept)            0.664388569  6.186885e-01  0.639434124  0.6919005812
## format_ITS_L6$Group11 -0.041796454 -5.866459e-02 -0.012693357  0.1440213670
## format_ITS_L6$Group12  0.088860933  8.654267e-02  0.042932796 -0.2455247298
## format_ITS_L6$Group13  0.075413427  2.993083e-02 -0.020502624  0.0006225972
## dph                   -0.002665273  3.508904e-05  0.001056008 -0.0063229350
##                             D04E09C      D04E09D      D04E09I      D04E09J
## (Intercept)            5.606680e-01  0.652982587  0.629575992  0.694695835
## format_ITS_L6$Group11 -1.114045e-02 -0.019347641  0.114261921  0.141161102
## format_ITS_L6$Group12  1.064303e-01  0.034838845 -0.157485341 -0.244985339
## format_ITS_L6$Group13  4.455373e-02 -0.012758688 -0.025629708  0.005141783
## dph                   -3.520988e-05  0.002394149 -0.004751608 -0.006602573
##                            D04E10C       D04E10D     D04E10I      D04E10J
## (Intercept)            0.573271017  0.6153272947  0.63461695  0.662549380
## format_ITS_L6$Group11 -0.015648533 -0.0436771147 -0.03359206  0.138870903
## format_ITS_L6$Group12  0.109403121  0.0782986090  0.06713641 -0.232028757
## format_ITS_L6$Group13  0.055840101  0.0066454084  0.05208699 -0.006885009
## dph                   -0.000576109  0.0007296506 -0.00318498 -0.005376360
##                           D07E01C      D07E01D       D07E01I      D07E01J
## (Intercept)            0.56397037  0.634062444  5.626386e-01  0.613715700
## format_ITS_L6$Group11 -0.02286595 -0.058610089  9.876290e-02  0.158609571
## format_ITS_L6$Group12  0.10497739  0.090918938 -3.131557e-02 -0.183159736
## format_ITS_L6$Group13  0.03382104  0.050360728 -8.145982e-02 -0.061263177
## dph                    0.00062562 -0.001119018  6.611907e-05 -0.003198992
##                            D07E02C      D07E02D      D07E02I      D07E02J
## (Intercept)            0.601919121  0.700595203  0.586689169  0.687063061
## format_ITS_L6$Group11 -0.020849352 -0.020601529  0.057570945  0.103100776
## format_ITS_L6$Group12  0.068180091  0.030991138 -0.037394446 -0.157986018
## format_ITS_L6$Group13  0.007022001 -0.020580454 -0.038383526 -0.011138086
## dph                    0.001880997  0.003076627 -0.001758464 -0.004757657
##                            D07E03C      D07E03D      D07E03I      D07E03J
## (Intercept)            0.616524950  0.628157360  0.647519808  0.662914833
## format_ITS_L6$Group11 -0.014694191 -0.038088664  0.024629927  0.094502165
## format_ITS_L6$Group12  0.090362727  0.077954456  0.010754192 -0.152417720
## format_ITS_L6$Group13  0.067864850  0.059765111 -0.017368035  0.009297855
## dph                   -0.003074118 -0.003324861 -0.002255789 -0.006081521
##                            D07E04C      D07E04D      D07E04I      D07E04J
## (Intercept)            0.623889468  0.623123791  0.663413652  0.762661902
## format_ITS_L6$Group11 -0.028332676 -0.014577899  0.045577853  0.026272436
## format_ITS_L6$Group12  0.111942580  0.031232776  0.034295868 -0.038339337
## format_ITS_L6$Group13  0.077320165  0.000459133 -0.060738766 -0.017154895
## dph                   -0.002287402 -0.001108934  0.002304219 -0.003019592
##                            D07E05C     D07E05D       D07E05I      D07E05J
## (Intercept)            0.624019969  0.60536110  6.476554e-01  0.588058391
## format_ITS_L6$Group11 -0.019244682 -0.04307030  7.389693e-02  0.131330172
## format_ITS_L6$Group12  0.097407059  0.10712589 -4.117073e-02 -0.136130618
## format_ITS_L6$Group13  0.072216514  0.07025094 -7.190334e-02 -0.047466016
## dph                   -0.002796044 -0.00241479  6.329961e-05 -0.003317247
##                            D07E06C      D07E06D      D07E06I      D07E06J
## (Intercept)            0.602027770  0.678901796  0.642171842  0.670607506
## format_ITS_L6$Group11 -0.028133135 -0.036258270  0.024852855  0.146470768
## format_ITS_L6$Group12  0.076669947  0.048332015  0.031239778 -0.242105634
## format_ITS_L6$Group13  0.019152268 -0.007271847 -0.046962815 -0.003383573
## dph                    0.001468217  0.002562932  0.002407159 -0.005953306
##                            D07E07C      D07E07D      D07E07I       D07E07J
## (Intercept)            0.628933454  0.785068979  0.766486406  6.897752e-01
## format_ITS_L6$Group11 -0.036258401 -0.017441822 -0.002627192  8.747103e-02
## format_ITS_L6$Group12  0.113210425  0.024421137  0.011712683 -1.232413e-01
## format_ITS_L6$Group13  0.082827610 -0.033873934 -0.042698563 -6.147792e-02
## dph                   -0.002817066  0.004084152  0.003804860  8.890707e-05
##                            D07E08C      D07E08D      D07E08I       D07E08J
## (Intercept)            0.598656069  0.668086288  0.812732155  0.7788233430
## format_ITS_L6$Group11  0.003379794  0.043275455 -0.013520295  0.0052585663
## format_ITS_L6$Group12  0.076496620 -0.046110609  0.021812375 -0.0007781362
## format_ITS_L6$Group13  0.053408413 -0.061137463 -0.038391727 -0.0474661394
## dph                   -0.002728719  0.001071743  0.004344569  0.0037398916
##                             D07E09C      D07E09D      D07E09I      D07E09J
## (Intercept)            0.5630061968  0.790361194  0.718162311  0.731342501
## format_ITS_L6$Group11 -0.0299145701 -0.016284784  0.025971199  0.022982272
## format_ITS_L6$Group12  0.1052407289  0.024397514 -0.021550044 -0.018875646
## format_ITS_L6$Group13  0.0412840089 -0.033997334 -0.057773655 -0.056985147
## dph                   -0.0007093455  0.004125582  0.003154068  0.003374374
##                             D07E10C     D07E10D       D07E10I      D07E10J
## (Intercept)            0.5827777791  0.64532085  0.6265555255  0.629957804
## format_ITS_L6$Group11 -0.0354697905 -0.03679462  0.0479696877  0.058064277
## format_ITS_L6$Group12  0.1120134630  0.06147729 -0.0329672821 -0.050741544
## format_ITS_L6$Group13  0.0573834296  0.01163570 -0.0665699247 -0.075535960
## dph                   -0.0004100084  0.00194366  0.0004129278  0.001803633
##                            D14E01C      D14E01D      D14E01I      D14E01J
## (Intercept)            0.625109370  0.668258585  0.638685866  0.629261726
## format_ITS_L6$Group11 -0.008041987 -0.039452029  0.169797293  0.162397992
## format_ITS_L6$Group12  0.056671659  0.054190474 -0.148980191 -0.156374998
## format_ITS_L6$Group13 -0.040148473 -0.007429603 -0.096610099 -0.089673552
## dph                    0.003573525  0.002468034 -0.001491982 -0.001736932
##                             D14E02C      D14E02D      D14E02I      D14E02J
## (Intercept)            0.6028639864  0.655232666  0.611016783  0.590677071
## format_ITS_L6$Group11 -0.0260368986 -0.046521225  0.084481124  0.160735292
## format_ITS_L6$Group12  0.0810344802  0.093726530  0.010709792 -0.157715916
## format_ITS_L6$Group13  0.0320802539  0.049460225 -0.080021606 -0.065726754
## dph                   -0.0009841831 -0.002616352  0.003327208 -0.002667998
##                            D14E03C      D14E03D       D14E03I       D14E03J
## (Intercept)            0.625825773  0.683134355  0.6348919590  0.5954551996
## format_ITS_L6$Group11 -0.031271315 -0.045608370  0.1352182522  0.1426205527
## format_ITS_L6$Group12  0.095072612  0.077440178 -0.0617001978 -0.0980358409
## format_ITS_L6$Group13  0.040117591  0.044620477 -0.0987390184 -0.0858307431
## dph                   -0.002202832 -0.002550651  0.0006294941 -0.0006112674
##                            D14E04C     D14E04D      D14E04I      D14E04J
## (Intercept)            0.607018044  0.70626179  0.549123889  0.601549183
## format_ITS_L6$Group11 -0.010860145 -0.06066589  0.073652479  0.156684605
## format_ITS_L6$Group12  0.088837941  0.08356867  0.017961258 -0.203318333
## format_ITS_L6$Group13  0.015462277  0.05639792 -0.074137101 -0.033495883
## dph                   -0.001019106 -0.00233669  0.002832137 -0.003958518
##                             D14E05C      D14E05D      D14E05I      D14E05J
## (Intercept)            0.5903959470  0.632529499  0.629443355  0.697554525
## format_ITS_L6$Group11  0.0092035335 -0.045582527  0.159998535  0.138925172
## format_ITS_L6$Group12  0.0596954601  0.102181643 -0.193548758 -0.243313961
## format_ITS_L6$Group13 -0.0077409936  0.059716573 -0.036749176  0.008222314
## dph                   -0.0004544664 -0.002261317 -0.005070244 -0.006689001
##                           D14E06C      D14E06D      D14E06I      D14E06J
## (Intercept)            0.57200095  0.651753695  0.566942147  0.677895745
## format_ITS_L6$Group11  0.06291256 -0.072448748  0.125622547  0.139868955
## format_ITS_L6$Group12  0.03359633  0.099110680 -0.098459443 -0.241502255
## format_ITS_L6$Group13 -0.05935908  0.065879208 -0.073558564  0.004018102
## dph                    0.00188095 -0.003475616 -0.001183973 -0.006060121
##                             D14E07C      D14E07D      D14E07I      D14E07J
## (Intercept)            0.6163629953  0.670220338  0.664947430  0.695665058
## format_ITS_L6$Group11  0.0396893140 -0.063498973  0.089034233  0.142823123
## format_ITS_L6$Group12  0.0597217277  0.099899722  0.003602491 -0.243447822
## format_ITS_L6$Group13 -0.0079801208  0.069265583 -0.079412696  0.003945245
## dph                   -0.0003783552 -0.002828374  0.002377220 -0.006666631
##                             D14E08C      D14E08D      D14E08I      D14E08J
## (Intercept)            5.786071e-01  0.737417853  0.612134411  0.700727450
## format_ITS_L6$Group11  1.172782e-02 -0.057428353  0.046574600  0.142014451
## format_ITS_L6$Group12  7.563145e-02  0.077137239 -0.026982025 -0.245095745
## format_ITS_L6$Group13  6.068254e-03  0.044497895 -0.019094933  0.005828610
## dph                   -2.350292e-05 -0.002545231 -0.003482623 -0.006675667
##                             D14E09C      D14E09D       D14E09I      D14E09J
## (Intercept)            0.6416625408  0.697471321  0.5929301985  0.623451773
## format_ITS_L6$Group11  0.0461561076 -0.038483058  0.0306280667  0.165735790
## format_ITS_L6$Group12  0.0434819596  0.067454579  0.0327932918 -0.172863285
## format_ITS_L6$Group13 -0.0170998482  0.061072960 -0.0182363505 -0.061163335
## dph                    0.0002182887 -0.002674295 -0.0008881436 -0.003408144
##                            D14E10C      D14E10D      D14E10I      D14E10J
## (Intercept)            0.678923141  0.661775862  0.675293021  0.685254051
## format_ITS_L6$Group11  0.144777458 -0.055166362  0.092459918  0.141738661
## format_ITS_L6$Group12 -0.239701819  0.102398030 -0.129049126 -0.242516030
## format_ITS_L6$Group13  0.002992408  0.046067151 -0.015238902  0.002931220
## dph                   -0.006469737 -0.002498858 -0.004712719 -0.006438143
##                             D21E01C      D21E01D      D21E01I       D21E01J
## (Intercept)            0.6396892693  0.686658903  0.675373714  0.6450408461
## format_ITS_L6$Group11  0.0286702833 -0.051517620  0.038097905  0.0909768503
## format_ITS_L6$Group12  0.0698608980  0.074288407  0.035822587 -0.0696772310
## format_ITS_L6$Group13 -0.0168273097  0.037947803 -0.059453618 -0.0592661267
## dph                    0.0005208209 -0.001671472  0.002791695 -0.0008221048
##                            D21E02C      D21E02D       D21E02I      D21E02J
## (Intercept)            0.671094191  0.684475475  0.5995307956  0.647718828
## format_ITS_L6$Group11 -0.058901800 -0.059684280  0.1109099265  0.164229601
## format_ITS_L6$Group12  0.086470489  0.095507275 -0.0434987852 -0.228272157
## format_ITS_L6$Group13  0.072505414  0.048935675 -0.0788135145 -0.023799124
## dph                   -0.003202946 -0.002401086 -0.0003333432 -0.005218625
##                           D21E03C      D21E03D       D21E03I      D21E03J
## (Intercept)            0.68434137  0.647974672  0.5894977228  0.679002336
## format_ITS_L6$Group11 -0.05751793 -0.054032496  0.0633392467  0.138463244
## format_ITS_L6$Group12  0.08262230  0.114504324  0.0090014234 -0.237181640
## format_ITS_L6$Group13  0.06402443  0.076476315 -0.0471791434  0.006928916
## dph                   -0.00288032 -0.002795834 -0.0007292962 -0.006376288
##                            D21E04C      D21E04D      D21E04I      D21E04J
## (Intercept)            0.696327051  0.640032375  0.616092393  0.708998405
## format_ITS_L6$Group11  0.144629770 -0.056321000  0.098231009  0.144461834
## format_ITS_L6$Group12 -0.246886024  0.103182381 -0.123760550 -0.246403108
## format_ITS_L6$Group13 -0.001289134  0.053817013 -0.010734988  0.001004808
## dph                   -0.006423470 -0.002576467 -0.005533299 -0.006529073
##                            D21E05C      D21E05D      D21E05I     D21E05J
## (Intercept)            0.612587604  0.725199287  0.630582802  0.64438199
## format_ITS_L6$Group11  0.033814063 -0.054347566  0.130196976  0.15023164
## format_ITS_L6$Group12  0.053686354  0.070576047 -0.158531785 -0.21759418
## format_ITS_L6$Group13 -0.007367328  0.042694311 -0.022992901 -0.02746840
## dph                   -0.001346769 -0.002475464 -0.005427052 -0.00488745
##                             D21E06C      D21E06D      D21E06I      D21E06J
## (Intercept)            0.6159241997  0.720290579  0.610081525  0.683514831
## format_ITS_L6$Group11  0.0397724830 -0.083481327  0.093466075  0.140162821
## format_ITS_L6$Group12  0.0481197556  0.095053022 -0.110508591 -0.239698245
## format_ITS_L6$Group13 -0.0112818720  0.062089172 -0.009379667  0.005574583
## dph                   -0.0006655072 -0.003314675 -0.005328952 -0.006537683
##                            D21E07C      D21E07D      D21E07I      D21E07J
## (Intercept)            0.597665583  0.649945038  0.733368904  0.675848315
## format_ITS_L6$Group11  0.038708065 -0.049169406  0.042968001  0.142993667
## format_ITS_L6$Group12  0.040571702  0.099466241 -0.051841468 -0.233545713
## format_ITS_L6$Group13  0.007156416  0.074751700 -0.021319051 -0.003967607
## dph                   -0.001881293 -0.002906771 -0.003626425 -0.005962825
##                            D21E08C      D21E08D      D21E08I      D21E08J
## (Intercept)            0.622215957  0.720677115  0.732486780  0.842477766
## format_ITS_L6$Group11 -0.007098751 -0.064527839  0.041020030  0.056739150
## format_ITS_L6$Group12  0.085914208  0.084004947 -0.048436676 -0.085048016
## format_ITS_L6$Group13  0.024655682  0.061428553 -0.020695021 -0.013205573
## dph                   -0.001343132 -0.003007862 -0.003581321 -0.002035098
##                            D21E09C      D21E09D      D21E09I      D21E09J
## (Intercept)            0.580528877  0.617709166  0.585314048  0.676349021
## format_ITS_L6$Group11  0.018991132 -0.035849770  0.071423590  0.147717522
## format_ITS_L6$Group12  0.076069054  0.091432023 -0.017299951 -0.240030947
## format_ITS_L6$Group13 -0.018798467  0.063356587 -0.043596292 -0.004355407
## dph                    0.001226959 -0.002137479 -0.002594297 -0.006301381
##                            D21E10C      D21E10D      D21E10I      D21E10J
## (Intercept)            0.707550387  0.638542488  0.650173739  0.668435030
## format_ITS_L6$Group11 -0.063806181 -0.046676844  0.015100844  0.133442077
## format_ITS_L6$Group12  0.082160227  0.095807199  0.001817473 -0.220376986
## format_ITS_L6$Group13  0.068267471  0.056999860  0.015230426  0.005535116
## dph                   -0.003239905 -0.002171429 -0.004166759 -0.006481769
##                            D28E01C      D28E01D       D28E01I     D28E01J
## (Intercept)            0.668242305  0.710384543  0.6430396364  0.64362934
## format_ITS_L6$Group11 -0.047745133 -0.052288824  0.0963822260  0.15380895
## format_ITS_L6$Group12  0.092193049  0.074928617 -0.0249269000 -0.22125184
## format_ITS_L6$Group13  0.046187016  0.039627128 -0.0632080020 -0.01676028
## dph                   -0.002990289 -0.002241839 -0.0002580592 -0.00557108
##                           D28E02C      D28E02D      D28E02I      D28E02J
## (Intercept)            0.65937444  0.714343458  0.634725299  0.672701623
## format_ITS_L6$Group11 -0.06493812 -0.052696787 -0.002531868  0.144876186
## format_ITS_L6$Group12  0.09218889  0.062103455  0.034606205 -0.234811682
## format_ITS_L6$Group13  0.06912712  0.042992449  0.009157221 -0.015022412
## dph                   -0.00321912 -0.003276059 -0.003449332 -0.005024675
##                            D28E03C      D28E03D      D28E03I      D28E03J
## (Intercept)            0.676078351  0.713035124  0.632119710  0.675844841
## format_ITS_L6$Group11 -0.038234857 -0.022248061  0.148638373  0.153407738
## format_ITS_L6$Group12  0.071379523  0.031839305 -0.101524571 -0.239906689
## format_ITS_L6$Group13  0.069632498  0.023893193 -0.100067751 -0.017733373
## dph                   -0.003235076 -0.003407919 -0.001786894 -0.005904463
##                           D28E04C      D28E04D     D28E04I      D28E04J
## (Intercept)            0.68931431  0.842202289  0.64485862  0.635105160
## format_ITS_L6$Group11 -0.04375086 -0.067574844  0.15901262  0.164540433
## format_ITS_L6$Group12  0.07092027  0.071691004 -0.12738228 -0.165919350
## format_ITS_L6$Group13  0.07381657  0.040975250 -0.09590107 -0.075226885
## dph                   -0.00333054 -0.002207318 -0.00224323 -0.002965341
##                            D28E05C      D28E05D      D28E05I      D28E05J
## (Intercept)            0.644690800  0.718483289  0.604587263  0.630880529
## format_ITS_L6$Group11  0.007709345 -0.068843140  0.108242899  0.156381124
## format_ITS_L6$Group12  0.036300900  0.081847660 -0.081845090 -0.210000866
## format_ITS_L6$Group13  0.020992783  0.049559777 -0.047250523 -0.027594042
## dph                   -0.002632346 -0.002834911 -0.003967215 -0.004964026
##                            D28E06C     D28E06D      D28E06I      D28E06J
## (Intercept)            0.653721846  0.66614311  0.572808826  0.668464272
## format_ITS_L6$Group11 -0.041728533 -0.05612002  0.062474230  0.146886430
## format_ITS_L6$Group12  0.092941242  0.10935346  0.023605351 -0.237321363
## format_ITS_L6$Group13  0.057463796  0.06322712 -0.068620418 -0.004160052
## dph                   -0.002647941 -0.00255600  0.002767452 -0.006051374
##                            D28E07C      D28E07D       D28E07I     D28E07J
## (Intercept)            0.656491242  0.730696129  0.6260976626  0.66660997
## format_ITS_L6$Group11 -0.019592998 -0.067834461  0.0048733967  0.01654501
## format_ITS_L6$Group12  0.048546144  0.088428054  0.0182486791 -0.02734476
## format_ITS_L6$Group13  0.037188446  0.049266816 -0.0127257162  0.03233093
## dph                   -0.002644347 -0.002746704 -0.0002645407 -0.00463508
##                            D28E08C      D28E08D      D28E08I      D28E08J
## (Intercept)            0.662593451  0.662178694  0.628904476  0.684698195
## format_ITS_L6$Group11 -0.048281975 -0.016089799  0.123929967  0.142796286
## format_ITS_L6$Group12  0.079850064  0.050362635 -0.112903164 -0.244219445
## format_ITS_L6$Group13  0.059394207  0.017879011 -0.080255935  0.001514418
## dph                   -0.002991484 -0.002872137 -0.002230139 -0.006282802
##                            D28E09C      D28E09D      D28E09I       D28E09J
## (Intercept)            0.685022565  0.860318599  0.624656538  0.6781754001
## format_ITS_L6$Group11 -0.057919183 -0.048499527  0.065895331  0.1455014812
## format_ITS_L6$Group12  0.074227386  0.032720088 -0.065780522 -0.2471113954
## format_ITS_L6$Group13  0.067320280  0.033443325 -0.023105705 -0.0008522401
## dph                   -0.002953454 -0.001924529 -0.004107568 -0.0060994510
##                            D28E10C     D28E10D       D28E10I      D28E10J
## (Intercept)            0.681071637  0.70220851  0.6648346939  0.651023718
## format_ITS_L6$Group11 -0.053507473 -0.04104751  0.0506621738  0.169674663
## format_ITS_L6$Group12  0.078184968  0.08647135  0.0301280749 -0.210942519
## format_ITS_L6$Group13  0.069567301  0.05112771 -0.0509101049 -0.041902016
## dph                   -0.003100886 -0.00199122  0.0002119654 -0.004614594
##                           D35E01C      D35E01D      D35E01I      D35E01J
## (Intercept)            0.63582557  0.665842987  0.585505174  0.640249932
## format_ITS_L6$Group11 -0.03534860 -0.050531108  0.110166859  0.157048142
## format_ITS_L6$Group12  0.11283332  0.106424020 -0.090682760 -0.215933187
## format_ITS_L6$Group13  0.08412361  0.037748446 -0.036127278 -0.020856228
## dph                   -0.00281525 -0.002534408 -0.004301957 -0.005247078
##                            D35E02C     D35E02D      D35E02I       D35E02J
## (Intercept)            0.638161263  0.66244436  0.588385524  6.755501e-01
## format_ITS_L6$Group11 -0.031568089 -0.06290793  0.091010002  1.303469e-01
## format_ITS_L6$Group12  0.112515526  0.09311934 -0.087763833 -2.056334e-01
## format_ITS_L6$Group13  0.077915629  0.06819438 -0.051698823  7.350873e-05
## dph                   -0.002774502 -0.00320187 -0.002446668 -6.629736e-03
##                            D35E03C      D35E03D      D35E03I      D35E03J
## (Intercept)            0.635715079  0.800221664  0.656997013  0.678706668
## format_ITS_L6$Group11 -0.027798346 -0.047538793  0.160441786  0.153211610
## format_ITS_L6$Group12  0.107743047  0.052907285 -0.180324967 -0.240428018
## format_ITS_L6$Group13  0.079216898  0.043526419 -0.059769668 -0.017802235
## dph                   -0.002819163 -0.002307788 -0.004365056 -0.005960881
##                            D35E04C      D35E04D      D35E04I      D35E04J
## (Intercept)            0.647215231  0.751066926  0.632273055  0.821249749
## format_ITS_L6$Group11 -0.034614278 -0.073967136 -0.015522499  0.089111227
## format_ITS_L6$Group12  0.112824924  0.084066181  0.085202753 -0.132034061
## format_ITS_L6$Group13  0.084161359  0.074273711  0.023759201 -0.025601077
## dph                   -0.002766171 -0.003249924 -0.001649147 -0.002997237
##                            D35E05C      D35E05D      D35E05I      D35E05J
## (Intercept)            0.642647932  0.706097472  0.706452145  0.659756554
## format_ITS_L6$Group11 -0.036869887 -0.046410251  0.177568413  0.161932167
## format_ITS_L6$Group12  0.113397060  0.095972479 -0.193195472 -0.209417595
## format_ITS_L6$Group13  0.084996957  0.029203141 -0.073016855 -0.027141538
## dph                   -0.002832664 -0.002094976 -0.003660285 -0.005611371
##                            D35E06C      D35E06D       D35E06I      D35E06J
## (Intercept)            0.645282977  0.664102357  6.993313e-01  0.768343407
## format_ITS_L6$Group11 -0.036253768 -0.058692721  6.590713e-02 -0.012828400
## format_ITS_L6$Group12  0.115618630  0.084926664 -2.536867e-02  0.011247102
## format_ITS_L6$Group13  0.084602747  0.072443388 -4.945610e-02  0.039229310
## dph                   -0.002830734 -0.003277193 -6.882980e-06 -0.002306193
##                            D35E07C      D35E07D     D35E07I      D35E07J
## (Intercept)            0.621578676  0.747115481  0.68078980  0.700055453
## format_ITS_L6$Group11  0.008639292 -0.066515112  0.05082650  0.142274619
## format_ITS_L6$Group12  0.055506391  0.069119560 -0.07063856 -0.243972505
## format_ITS_L6$Group13  0.050056501  0.055871857  0.01477934  0.001327974
## dph                   -0.003844159 -0.002842448 -0.00556067 -0.006622855
##                            D35E08C      D35E08D      D35E08I      D35E08J
## (Intercept)            0.630492313  0.704195386  0.691233428  0.694440586
## format_ITS_L6$Group11 -0.026183881 -0.013301020  0.081887927  0.143374919
## format_ITS_L6$Group12  0.101793121  0.046892895 -0.121705786 -0.239068799
## format_ITS_L6$Group13  0.076937196  0.016915716 -0.014883610 -0.002145140
## dph                   -0.003105613 -0.002268351 -0.005579944 -0.006545445
##                            D35E09C      D35E09D      D35E09I      D35E09J
## (Intercept)            0.644514360  0.687101903  0.629762498  0.673918423
## format_ITS_L6$Group11 -0.038587022 -0.050575751  0.096760254  0.143344760
## format_ITS_L6$Group12  0.117109972  0.084862502 -0.128134145 -0.236591674
## format_ITS_L6$Group13  0.084287749  0.037771714 -0.006160353 -0.006989772
## dph                   -0.002801311 -0.002606057 -0.005848936 -0.006044157
##                            D35E10C      D35E10D      D35E10I      D35E10J
## (Intercept)            0.640318728  0.708874155  0.621094183  0.696978039
## format_ITS_L6$Group11 -0.036735058 -0.003095329  0.092923843  0.132198177
## format_ITS_L6$Group12  0.115152619  0.002076144 -0.118894525 -0.230067241
## format_ITS_L6$Group13  0.083248320  0.006511167 -0.008268087  0.002820010
## dph                   -0.002755608 -0.003882465 -0.005615819 -0.006224402
##                            D42E01C      D42E01D      D42E01I      D42E01J
## (Intercept)            0.643494390  0.663403786  0.577417035  0.639083707
## format_ITS_L6$Group11 -0.045278220 -0.065992173  0.043475038  0.098348176
## format_ITS_L6$Group12  0.105458496  0.099266633 -0.002864060 -0.112210405
## format_ITS_L6$Group13  0.065839191  0.062008953 -0.017281531 -0.031530108
## dph                   -0.003065745 -0.003449297 -0.001809717 -0.003546209
##                            D42E02C      D42E02D      D42E02I      D42E02J
## (Intercept)            0.653004832  0.692785159  0.593379562  0.669861669
## format_ITS_L6$Group11  0.056953954 -0.031980422  0.019324685  0.128244308
## format_ITS_L6$Group12 -0.067864289  0.034968355  0.004774292 -0.217022763
## format_ITS_L6$Group13  0.004514678  0.039092502 -0.012490517  0.004256728
## dph                   -0.005659100 -0.003875078 -0.001697433 -0.005805082
##                            D42E03C      D42E03D      D42E03I      D42E03J
## (Intercept)            0.697950318  0.738748869  0.742411241  0.687194698
## format_ITS_L6$Group11  0.113521671 -0.047021724  0.137061326  0.140198580
## format_ITS_L6$Group12 -0.169218540  0.068551475 -0.200969593 -0.244490740
## format_ITS_L6$Group13 -0.003755590  0.037740087 -0.041781839  0.005447261
## dph                   -0.006026189 -0.002484402 -0.005034226 -0.006410594
##                            D42E04C      D42E04D      D42E04I      D42E04J
## (Intercept)            0.750077229  0.706066829  0.624249186  0.631753103
## format_ITS_L6$Group11 -0.008157903 -0.060183710  0.043010811  0.141040983
## format_ITS_L6$Group12  0.013603992  0.068532470 -0.032440516 -0.181566304
## format_ITS_L6$Group13  0.001208351  0.066282769 -0.002919588 -0.019582811
## dph                   -0.003690404 -0.003347738 -0.004270276 -0.004965868
##                             D42E05C      D42E05D      D42E05I      D42E05J
## (Intercept)            0.9018635396  0.648847574  0.677635002  0.702221054
## format_ITS_L6$Group11 -0.0245002987 -0.027669997  0.129362293  0.141655214
## format_ITS_L6$Group12  0.0319795912  0.046716987 -0.197712853 -0.245916655
## format_ITS_L6$Group13 -0.0007008622  0.040483783 -0.004663462  0.006660021
## dph                   -0.0020563063 -0.003894144 -0.006671931 -0.006706501
##                            D42E06C      D42E06D      D42E06I      D42E06J
## (Intercept)            0.759267576  0.689387393  0.761176448  0.695165102
## format_ITS_L6$Group11  0.008353022 -0.016849765  0.138610883  0.144776949
## format_ITS_L6$Group12 -0.005265514  0.025719146 -0.197415916 -0.247607262
## format_ITS_L6$Group13 -0.008632069  0.028601304 -0.039472506  0.001946289
## dph                   -0.004391565 -0.003873242 -0.005292259 -0.006445268
##                            D42E07C      D42E07D      D42E07I      D42E07J
## (Intercept)            0.927319286  0.717624849  0.696042602  0.692069089
## format_ITS_L6$Group11 -0.037494954  0.146778040  0.149161131  0.155062638
## format_ITS_L6$Group12  0.043596934 -0.235452263 -0.203168054 -0.244767096
## format_ITS_L6$Group13  0.007812958 -0.020536057 -0.031491533 -0.012177171
## dph                   -0.001779724 -0.006044983 -0.005793069 -0.006111366
##                            D42E08C      D42E08D      D42E08I      D42E08J
## (Intercept)            0.621789126  0.762564240  0.642617748  0.677743230
## format_ITS_L6$Group11 -0.017349937 -0.034736745  0.069042035  0.141392888
## format_ITS_L6$Group12  0.089411236  0.052890182 -0.075913868 -0.239600624
## format_ITS_L6$Group13  0.028071868  0.026502621 -0.012362228  0.002964683
## dph                   -0.002144361 -0.002474905 -0.004758898 -0.006282969
##                           D42E09C      D42E09D      D42E09I      D42E09J
## (Intercept)            0.69297609  0.703883266  0.619784296  0.695365836
## format_ITS_L6$Group11 -0.03919687  0.138830399  0.096716507  0.099954790
## format_ITS_L6$Group12  0.07068631 -0.248680143 -0.097802219 -0.092417888
## format_ITS_L6$Group13  0.03011693  0.006999323 -0.033433053 -0.040534002
## dph                   -0.00308606 -0.006557444 -0.004803543 -0.002500906
##                            D42E10C      D42E10D      D42E10I      D42E10J
## (Intercept)            0.683230752  0.743865110  0.689131062  0.619927618
## format_ITS_L6$Group11  0.134298238  0.082924192  0.150653484  0.153418693
## format_ITS_L6$Group12 -0.205912290 -0.157330245 -0.192803493 -0.168073636
## format_ITS_L6$Group13 -0.005866023 -0.005829311 -0.054049370 -0.049053709
## dph                   -0.006672311 -0.005472711 -0.004904815 -0.003786972
## 
## $f.perms
##              [,1]      [,2]
##    [1,] 0.7772190 1.2586514
##    [2,] 1.1124924 0.4688952
##    [3,] 0.7517511 0.6611874
##    [4,] 0.9912349 0.4676957
##    [5,] 0.8750143 0.9769554
##    [6,] 1.1916090 1.1878459
##    [7,] 1.0669983 0.4822288
##    [8,] 1.3843309 1.8024742
##    [9,] 0.7679267 1.9896025
##   [10,] 0.9850710 1.2078939
##   [11,] 0.9120204 0.7803651
##   [12,] 0.9788587 0.6285872
##   [13,] 0.7152957 0.9793500
##   [14,] 1.0406060 0.9561501
##   [15,] 0.6043241 0.6525482
##   [16,] 0.9226102 0.6616327
##   [17,] 1.4198217 0.4770682
##   [18,] 0.8962262 0.7412501
##   [19,] 1.5712336 0.5281711
##   [20,] 0.7659417 1.0602638
##   [21,] 1.3925415 1.1897809
##   [22,] 0.6356637 1.2789739
##   [23,] 0.8314281 0.4204065
##   [24,] 1.5606240 1.0237576
##   [25,] 0.7230068 0.6959534
##   [26,] 1.1319228 0.8122925
##   [27,] 1.1210994 0.6796731
##   [28,] 1.1822848 1.0629760
##   [29,] 1.2255670 1.1019758
##   [30,] 1.0896904 1.1302351
##   [31,] 0.9283175 1.0388180
##   [32,] 1.3539215 0.6611226
##   [33,] 1.0996625 0.8559412
##   [34,] 1.1010769 1.5642064
##   [35,] 1.6775864 0.6840739
##   [36,] 0.9752055 0.8850920
##   [37,] 1.6499102 1.2019148
##   [38,] 1.2401865 0.2679218
##   [39,] 0.6992567 0.6348930
##   [40,] 0.9146253 0.6605898
##   [41,] 1.3021449 1.3575740
##   [42,] 1.5845741 1.2170973
##   [43,] 0.9417097 0.9954602
##   [44,] 0.5615768 0.6740529
##   [45,] 1.2864209 0.5045068
##   [46,] 0.6802190 0.8275945
##   [47,] 1.5058375 0.9025698
##   [48,] 1.2354938 1.3503550
##   [49,] 0.7392146 1.2476435
##   [50,] 1.2264328 1.5429359
##   [51,] 1.0885602 1.4861145
##   [52,] 1.0946281 0.4684118
##   [53,] 1.0664583 1.2489420
##   [54,] 1.1850874 0.7708732
##   [55,] 1.1770975 2.4737643
##   [56,] 1.9736504 0.7950140
##   [57,] 0.8035077 1.1643184
##   [58,] 1.4294813 1.1591029
##   [59,] 1.2210014 0.3852210
##   [60,] 0.8916662 0.6407141
##   [61,] 1.2451384 0.7440947
##   [62,] 0.7336874 1.6380821
##   [63,] 1.0301053 0.4132847
##   [64,] 0.8725425 1.0735072
##   [65,] 1.3786278 0.3730918
##   [66,] 1.0682161 1.0283393
##   [67,] 0.7840510 0.5886935
##   [68,] 0.8079643 0.5153221
##   [69,] 1.3026254 0.6620040
##   [70,] 1.5021274 1.9372033
##   [71,] 0.9445383 1.0213124
##   [72,] 0.6988009 0.9528277
##   [73,] 0.8689208 1.2509069
##   [74,] 0.7404525 1.3682930
##   [75,] 0.8850967 0.9234044
##   [76,] 0.9926842 0.7613645
##   [77,] 1.2073384 1.3446627
##   [78,] 0.8031069 1.1815662
##   [79,] 1.1002689 0.3835265
##   [80,] 0.7224017 1.5002102
##   [81,] 0.6795157 1.0826350
##   [82,] 0.5856860 1.0393010
##   [83,] 0.9333645 1.2252794
##   [84,] 0.7846401 1.2883346
##   [85,] 1.0911341 0.9122587
##   [86,] 1.1471092 1.1601808
##   [87,] 1.6129653 0.9702803
##   [88,] 0.8159558 1.1687348
##   [89,] 0.9303156 2.3581518
##   [90,] 1.2620199 2.8515054
##   [91,] 0.9935995 1.3079104
##   [92,] 0.9014113 1.8970124
##   [93,] 0.6924988 0.5277667
##   [94,] 1.2026535 1.1036502
##   [95,] 0.8123396 0.2986703
##   [96,] 0.8613694 0.5929718
##   [97,] 0.9963920 1.1354428
##   [98,] 1.0197590 0.7741885
##   [99,] 1.1935050 0.4843679
##  [100,] 0.7636461 0.3370896
##  [101,] 0.9478635 0.7995904
##  [102,] 0.9001757 0.8468215
##  [103,] 0.6549786 0.7087802
##  [104,] 1.0908438 1.3441803
##  [105,] 1.0806889 1.0284754
##  [106,] 0.5990235 1.9813756
##  [107,] 1.4695412 1.2912859
##  [108,] 0.5774273 1.2793118
##  [109,] 0.8989985 0.5877906
##  [110,] 1.5502224 0.8330217
##  [111,] 0.8486363 1.4878510
##  [112,] 1.1864635 1.4992889
##  [113,] 0.8582710 1.1655025
##  [114,] 1.2597195 0.4115551
##  [115,] 0.9764838 1.1229534
##  [116,] 1.1759937 0.9943094
##  [117,] 0.5193730 1.5374956
##  [118,] 0.8444141 1.0080195
##  [119,] 1.7119668 1.2521325
##  [120,] 0.7746055 0.7082252
##  [121,] 0.9379411 0.3282578
##  [122,] 0.9005952 0.9715573
##  [123,] 1.0281971 0.4096408
##  [124,] 1.0640991 0.5649797
##  [125,] 1.0452815 0.6764023
##  [126,] 0.8582341 2.9226923
##  [127,] 0.7987267 1.8632273
##  [128,] 1.0555583 0.5142840
##  [129,] 1.0214278 0.8905449
##  [130,] 2.0319534 0.4266842
##  [131,] 0.9979862 0.6945276
##  [132,] 0.6432922 0.4273948
##  [133,] 0.8639008 1.5198276
##  [134,] 0.8538535 0.7691903
##  [135,] 0.8931128 1.1912302
##  [136,] 0.6319675 0.8412603
##  [137,] 0.8724690 0.7006539
##  [138,] 0.5661826 1.4343742
##  [139,] 0.9851378 0.5417931
##  [140,] 0.6655547 3.5431829
##  [141,] 0.9674407 1.0590864
##  [142,] 0.6364584 1.1526151
##  [143,] 1.5298838 0.8599908
##  [144,] 1.1447321 1.4977651
##  [145,] 0.8859720 1.1863827
##  [146,] 0.9141840 0.4173121
##  [147,] 0.4867462 1.4767314
##  [148,] 1.2110716 0.5270166
##  [149,] 1.2575939 0.6281505
##  [150,] 0.5833659 0.8985951
##  [151,] 0.8550621 0.8080566
##  [152,] 0.9624121 0.7476045
##  [153,] 0.7147357 0.5292040
##  [154,] 1.0823485 1.5120869
##  [155,] 1.1971955 1.0819428
##  [156,] 1.3974235 1.0084911
##  [157,] 0.9180194 0.6685900
##  [158,] 1.0444530 1.2430428
##  [159,] 0.8918141 2.1046622
##  [160,] 1.2192883 2.1124274
##  [161,] 0.9227158 1.5504557
##  [162,] 0.7030517 1.4174036
##  [163,] 1.0933442 0.9730552
##  [164,] 1.0158884 1.1437149
##  [165,] 0.5662319 1.5079211
##  [166,] 0.8443889 0.8765615
##  [167,] 0.8073241 0.3434904
##  [168,] 0.6824382 1.7036534
##  [169,] 1.0768858 0.6457563
##  [170,] 1.3927669 1.4717508
##  [171,] 0.8685720 0.8261250
##  [172,] 0.8330381 0.9057664
##  [173,] 1.1660516 1.0762842
##  [174,] 0.7653018 1.0297665
##  [175,] 0.8775335 1.7861610
##  [176,] 0.6647472 1.4514424
##  [177,] 1.3341290 0.4700535
##  [178,] 0.8930535 1.0053070
##  [179,] 0.7224901 0.6135975
##  [180,] 0.9978319 1.1193461
##  [181,] 0.8755210 0.4405424
##  [182,] 0.6168218 1.2690212
##  [183,] 0.7095460 1.0613804
##  [184,] 0.8140367 0.8774193
##  [185,] 1.2544351 2.1661362
##  [186,] 1.3166021 0.5866864
##  [187,] 1.1240569 0.9507210
##  [188,] 0.8199673 0.7417424
##  [189,] 0.5603825 0.9173009
##  [190,] 0.7890448 1.3794163
##  [191,] 0.6798882 0.9255731
##  [192,] 0.7185629 0.8607894
##  [193,] 0.6127871 1.6787818
##  [194,] 0.7986902 1.6472639
##  [195,] 0.5772520 2.2332628
##  [196,] 0.5530169 0.5069977
##  [197,] 1.0100403 0.7732835
##  [198,] 0.8542255 1.2250848
##  [199,] 1.1571254 0.6923668
##  [200,] 0.8123530 0.2462481
##  [201,] 0.8609200 0.5663951
##  [202,] 1.2735374 1.3391852
##  [203,] 1.2737877 1.0727336
##  [204,] 0.8739697 0.5891075
##  [205,] 1.0908792 0.6531902
##  [206,] 0.6833711 0.7424224
##  [207,] 1.0667792 1.1178535
##  [208,] 0.7734190 0.7522874
##  [209,] 0.9671575 0.5733863
##  [210,] 1.0817020 0.7771713
##  [211,] 1.0368368 1.5313686
##  [212,] 1.0085332 0.8623992
##  [213,] 1.1516002 1.6305381
##  [214,] 0.7711152 1.1674146
##  [215,] 1.1790106 1.1478283
##  [216,] 0.8621686 1.3322255
##  [217,] 0.8256096 0.3867738
##  [218,] 1.1910839 0.5699339
##  [219,] 0.8179536 0.7337225
##  [220,] 0.7493707 0.8388442
##  [221,] 0.8788853 0.7253001
##  [222,] 0.9159967 3.8146165
##  [223,] 0.8837977 0.4662575
##  [224,] 1.0956738 0.6838018
##  [225,] 1.1478005 0.3205603
##  [226,] 1.6253970 0.3458481
##  [227,] 1.8486854 1.9654753
##  [228,] 1.1095848 1.0756095
##  [229,] 1.1344026 1.1118979
##  [230,] 0.7083103 1.1660488
##  [231,] 1.1964316 1.0605121
##  [232,] 0.6406311 1.1548185
##  [233,] 1.8542766 0.3851084
##  [234,] 0.7912254 0.8510145
##  [235,] 0.6040964 0.8611061
##  [236,] 1.9888619 0.5163045
##  [237,] 0.9727333 1.0539852
##  [238,] 1.1320484 0.8023698
##  [239,] 0.8920166 1.0417091
##  [240,] 0.9000626 0.9912585
##  [241,] 1.0100486 1.6104083
##  [242,] 0.6068701 0.6343322
##  [243,] 0.6571175 0.3836675
##  [244,] 1.4001945 1.4968561
##  [245,] 1.0876777 2.5229151
##  [246,] 0.8109511 2.2912324
##  [247,] 0.6816487 0.9465106
##  [248,] 1.1074007 0.5689624
##  [249,] 1.0273254 0.5838958
##  [250,] 0.7122583 1.3018319
##  [251,] 0.7894920 0.5148216
##  [252,] 1.5764909 1.6899380
##  [253,] 0.9014711 0.7303376
##  [254,] 0.9286944 1.2796606
##  [255,] 1.5771895 0.7615720
##  [256,] 0.9553490 0.5691003
##  [257,] 0.9803789 1.0273223
##  [258,] 0.8835042 1.4318164
##  [259,] 0.7758359 1.0402206
##  [260,] 1.7452406 1.1825489
##  [261,] 0.7793655 1.0842371
##  [262,] 1.1397198 0.9179326
##  [263,] 0.7399479 1.5541211
##  [264,] 0.4739870 0.4757286
##  [265,] 0.8355927 0.6888424
##  [266,] 1.5887441 0.9010598
##  [267,] 0.6491735 0.7290809
##  [268,] 0.9432852 1.6914753
##  [269,] 0.7045753 0.7879088
##  [270,] 1.0081321 1.0712177
##  [271,] 0.9989766 1.1781602
##  [272,] 0.9054459 0.9616082
##  [273,] 1.0488444 1.0937634
##  [274,] 0.6648263 0.3909127
##  [275,] 1.1650208 1.3608372
##  [276,] 1.1822843 1.5865799
##  [277,] 0.9232208 0.5308225
##  [278,] 0.6524127 0.5857024
##  [279,] 1.0136512 0.6599322
##  [280,] 0.9413478 2.1598545
##  [281,] 0.7512630 1.2732010
##  [282,] 0.7946778 0.9955530
##  [283,] 0.6165697 1.1056085
##  [284,] 0.5754446 0.6745031
##  [285,] 0.8159452 1.3004210
##  [286,] 0.9481936 1.4647292
##  [287,] 1.4462567 2.5652174
##  [288,] 0.8581496 1.7299715
##  [289,] 0.7535816 0.4646235
##  [290,] 0.9715447 1.8159811
##  [291,] 0.8405378 0.2620275
##  [292,] 0.7950963 0.7152597
##  [293,] 0.6763608 1.2523273
##  [294,] 2.0051802 1.0790506
##  [295,] 0.9365411 0.4489875
##  [296,] 0.6919452 0.8873010
##  [297,] 0.9252821 0.7531921
##  [298,] 1.2685315 0.9296643
##  [299,] 0.7853733 0.9436442
##  [300,] 0.6627749 0.9189853
##  [301,] 0.8366460 2.4545912
##  [302,] 1.1020195 3.2212571
##  [303,] 1.6272796 1.1942561
##  [304,] 1.1509273 0.7485938
##  [305,] 1.2795138 0.5373845
##  [306,] 1.0018635 0.6169239
##  [307,] 0.5764910 0.9445279
##  [308,] 0.8891639 1.2779458
##  [309,] 1.1886277 1.9038216
##  [310,] 0.5500636 0.8056437
##  [311,] 1.5166857 0.6743036
##  [312,] 0.4957199 1.0216501
##  [313,] 0.9026935 0.8307110
##  [314,] 1.2993765 0.5378138
##  [315,] 1.5681136 1.0547787
##  [316,] 0.9899203 0.3128268
##  [317,] 1.2319652 0.5144073
##  [318,] 0.6437974 0.5867915
##  [319,] 0.8645756 0.6296413
##  [320,] 0.8984548 0.5345106
##  [321,] 0.6873667 0.4727199
##  [322,] 0.8418265 0.9102132
##  [323,] 0.6787468 0.9730486
##  [324,] 0.8463025 1.1416450
##  [325,] 1.3554579 1.9084264
##  [326,] 1.2103245 0.8512025
##  [327,] 1.1420971 0.8000398
##  [328,] 0.9537123 0.7539598
##  [329,] 0.6573935 0.8503987
##  [330,] 0.9629740 0.7781065
##  [331,] 0.7133707 1.0179251
##  [332,] 0.7107980 0.6089518
##  [333,] 1.3566947 0.3634183
##  [334,] 1.6532059 0.8038454
##  [335,] 0.5951031 0.7256329
##  [336,] 1.3145816 1.2626236
##  [337,] 0.9427130 1.0403379
##  [338,] 1.4531629 0.4229371
##  [339,] 0.6984283 0.7233639
##  [340,] 0.8941491 1.1529123
##  [341,] 1.0074316 0.5292275
##  [342,] 0.8833566 0.4848042
##  [343,] 1.1011081 0.6323451
##  [344,] 0.6306597 0.8017588
##  [345,] 0.7955203 1.1981173
##  [346,] 1.1648568 0.5392557
##  [347,] 1.3187890 0.5060119
##  [348,] 0.7511423 1.1597947
##  [349,] 1.1521141 0.7295023
##  [350,] 0.8442970 0.4903670
##  [351,] 1.1640909 0.7440535
##  [352,] 0.7136871 3.0752392
##  [353,] 1.0619038 1.3655532
##  [354,] 1.1057961 0.5296154
##  [355,] 0.9774961 0.8833157
##  [356,] 0.9412794 1.8428898
##  [357,] 0.6427650 1.7150959
##  [358,] 0.8977247 0.7136781
##  [359,] 1.4954576 1.4522540
##  [360,] 0.6046665 1.7453553
##  [361,] 1.0411637 0.6710399
##  [362,] 1.1362488 0.7964738
##  [363,] 1.2829608 0.4129452
##  [364,] 1.5479866 0.9803195
##  [365,] 1.2564834 0.4347843
##  [366,] 0.9902196 0.6917526
##  [367,] 0.9626614 0.8044098
##  [368,] 1.0089134 0.4385177
##  [369,] 0.9463445 0.6014696
##  [370,] 0.8392840 0.6012662
##  [371,] 0.6509093 0.2541876
##  [372,] 1.3612995 0.5910877
##  [373,] 0.9072773 0.5871035
##  [374,] 0.9804836 0.6044828
##  [375,] 0.8195843 2.0647173
##  [376,] 0.8738021 0.9049888
##  [377,] 1.2685665 0.5468100
##  [378,] 0.9144135 2.0677798
##  [379,] 1.2476062 0.6842377
##  [380,] 1.3420907 0.9610560
##  [381,] 0.8738758 0.7275580
##  [382,] 0.8999356 0.9617769
##  [383,] 0.8045584 0.7149667
##  [384,] 1.1569969 0.6439556
##  [385,] 0.9353757 1.2859928
##  [386,] 0.7171788 0.6673690
##  [387,] 1.7848653 1.0149734
##  [388,] 0.9894501 0.9974848
##  [389,] 1.0012994 0.7101286
##  [390,] 0.5613522 1.2797475
##  [391,] 0.9672252 1.6267599
##  [392,] 0.8402705 0.6169128
##  [393,] 1.0137672 1.4951687
##  [394,] 0.9454823 0.4297129
##  [395,] 0.7653937 0.8224729
##  [396,] 0.8837091 0.8468187
##  [397,] 1.0306253 0.6109307
##  [398,] 0.8340088 0.8786155
##  [399,] 1.0226555 0.4512580
##  [400,] 1.2300673 0.6976207
##  [401,] 1.0798239 0.8583208
##  [402,] 0.9503964 1.3927833
##  [403,] 1.0502010 1.1757230
##  [404,] 0.9120864 2.4981471
##  [405,] 0.9045924 0.6401348
##  [406,] 0.8797347 1.0056236
##  [407,] 1.4979149 1.6278845
##  [408,] 0.6514472 0.6221976
##  [409,] 0.6992407 1.5154192
##  [410,] 0.5606661 1.8832670
##  [411,] 0.8958029 0.7082378
##  [412,] 0.6484049 0.6477854
##  [413,] 0.8678815 0.8555235
##  [414,] 0.9292139 1.1248332
##  [415,] 1.0119985 0.4845451
##  [416,] 0.5785750 0.7469926
##  [417,] 0.8295742 0.6204196
##  [418,] 1.1303619 1.6446618
##  [419,] 0.8182756 1.1740984
##  [420,] 0.8561117 1.7539335
##  [421,] 0.6810370 0.7575204
##  [422,] 0.9092576 1.0644710
##  [423,] 1.1132777 0.8934230
##  [424,] 1.4575844 1.0962072
##  [425,] 1.5198010 0.6141117
##  [426,] 0.5802711 1.7973687
##  [427,] 1.1798742 0.7682241
##  [428,] 0.5996397 0.8477026
##  [429,] 0.7301143 1.4471780
##  [430,] 0.6320663 0.6374584
##  [431,] 0.9411261 0.3414300
##  [432,] 1.7534720 1.8764001
##  [433,] 1.0908744 0.6692369
##  [434,] 1.1183220 1.2952228
##  [435,] 0.9538714 1.0566462
##  [436,] 0.9084172 1.2755313
##  [437,] 0.8761125 0.4978030
##  [438,] 0.8840464 1.1942449
##  [439,] 1.4172695 0.6810016
##  [440,] 1.0036601 1.0731225
##  [441,] 0.5682183 0.5021621
##  [442,] 1.2961900 2.7488771
##  [443,] 1.0236122 0.5595075
##  [444,] 0.9552328 0.4161285
##  [445,] 0.8320923 0.8110836
##  [446,] 0.8863700 1.2024585
##  [447,] 0.8412762 3.3291828
##  [448,] 0.8285613 1.2250658
##  [449,] 0.5622519 1.1397778
##  [450,] 0.9332299 1.0723791
##  [451,] 0.8187734 1.0921189
##  [452,] 0.9282803 0.8309876
##  [453,] 0.6299401 1.6875351
##  [454,] 0.9892868 0.6524881
##  [455,] 1.1913957 0.3269996
##  [456,] 1.2787945 0.8220989
##  [457,] 1.7386766 0.7343528
##  [458,] 0.5591448 0.6264227
##  [459,] 0.6849173 0.8916093
##  [460,] 0.9090068 1.6652035
##  [461,] 0.9817511 0.6155974
##  [462,] 1.1805479 0.6071030
##  [463,] 1.4542526 0.7820216
##  [464,] 0.8149574 0.9962343
##  [465,] 1.0597538 0.6108250
##  [466,] 1.3707793 1.1843207
##  [467,] 0.4977019 0.6823268
##  [468,] 1.3679286 0.5430502
##  [469,] 1.0736363 2.2025931
##  [470,] 0.8792136 1.4173417
##  [471,] 1.3663785 0.4869978
##  [472,] 0.8516844 0.4423752
##  [473,] 0.6599501 1.2764585
##  [474,] 0.7886507 0.8650957
##  [475,] 1.1904669 0.4744283
##  [476,] 0.8800674 1.1805577
##  [477,] 0.5932903 0.4581846
##  [478,] 0.6344243 3.6942008
##  [479,] 0.6693389 0.6433042
##  [480,] 0.8406781 0.7189760
##  [481,] 1.2784553 1.7044669
##  [482,] 1.0377050 1.3884235
##  [483,] 1.2322596 0.7352291
##  [484,] 0.5848644 1.0645799
##  [485,] 1.6197250 0.4234083
##  [486,] 0.8363084 1.2949416
##  [487,] 0.8840366 1.3831591
##  [488,] 0.9391463 0.5450112
##  [489,] 0.9405209 0.5893779
##  [490,] 0.7453681 1.3122928
##  [491,] 1.0884813 1.3042735
##  [492,] 0.9914750 3.4654629
##  [493,] 1.2147510 0.5758937
##  [494,] 1.1028729 0.9312528
##  [495,] 0.6305710 0.6849255
##  [496,] 1.0051892 0.9829548
##  [497,] 0.7399491 1.0169211
##  [498,] 0.6874241 1.7479028
##  [499,] 1.3954745 0.8201098
##  [500,] 0.8575135 1.0890353
##  [501,] 0.9053154 2.2913658
##  [502,] 1.1419272 0.5711394
##  [503,] 1.1286182 1.2819834
##  [504,] 0.7558368 0.3085936
##  [505,] 0.9550246 0.9154517
##  [506,] 1.1177822 0.5109302
##  [507,] 1.0539086 1.6750421
##  [508,] 0.8159341 1.1934495
##  [509,] 0.7604150 0.7218939
##  [510,] 0.7458918 0.7008315
##  [511,] 0.7212312 0.6707415
##  [512,] 1.1442534 0.9685368
##  [513,] 0.7492965 1.5791283
##  [514,] 1.1118517 0.9748875
##  [515,] 0.7232743 0.7464081
##  [516,] 1.1501641 0.8549977
##  [517,] 1.0189118 1.2161944
##  [518,] 0.9091392 2.8364594
##  [519,] 0.8874395 1.1007029
##  [520,] 0.7711168 1.2947730
##  [521,] 1.0413505 0.3386438
##  [522,] 1.0344636 0.8701621
##  [523,] 0.8831970 1.5124844
##  [524,] 0.5683960 0.7932165
##  [525,] 0.6857799 3.3573292
##  [526,] 1.2905573 0.8648654
##  [527,] 0.6308487 1.1031547
##  [528,] 0.9637060 1.3324902
##  [529,] 1.2441029 1.1744668
##  [530,] 0.8699672 1.3361685
##  [531,] 0.9878395 0.7923211
##  [532,] 0.7286515 2.9342760
##  [533,] 1.0165958 0.6948123
##  [534,] 1.0047878 1.1433588
##  [535,] 0.8756678 0.8667909
##  [536,] 0.8194136 1.3756838
##  [537,] 1.0568354 1.7756132
##  [538,] 1.0219697 0.3448961
##  [539,] 1.1852050 0.9098568
##  [540,] 0.3901565 1.1772523
##  [541,] 0.9717482 1.7231880
##  [542,] 0.9654246 0.5749150
##  [543,] 0.8881189 1.8533441
##  [544,] 0.8058592 0.7083219
##  [545,] 0.7220091 1.8006823
##  [546,] 0.8541907 1.4147568
##  [547,] 1.2267268 0.5816791
##  [548,] 0.9582136 0.4504741
##  [549,] 0.7271898 1.1819203
##  [550,] 0.7756761 0.9783518
##  [551,] 0.6763156 0.4640449
##  [552,] 1.0083563 0.9804620
##  [553,] 1.1919688 1.3742886
##  [554,] 1.2662335 0.9466004
##  [555,] 0.5683286 0.4740706
##  [556,] 1.0403337 1.0311594
##  [557,] 0.5817078 0.9765211
##  [558,] 0.6908643 1.5540889
##  [559,] 0.6488270 0.9095582
##  [560,] 0.5281679 0.7172176
##  [561,] 1.0064450 1.3236642
##  [562,] 0.5189638 0.9513590
##  [563,] 1.1375101 0.8395958
##  [564,] 0.9221807 0.7995291
##  [565,] 0.6636926 0.3720323
##  [566,] 0.7509755 0.4101945
##  [567,] 0.6715964 0.6239826
##  [568,] 1.0547979 0.4614440
##  [569,] 0.8328705 0.4448527
##  [570,] 1.0316238 1.2829173
##  [571,] 0.7170832 0.3134149
##  [572,] 1.0871094 1.3872183
##  [573,] 0.6599500 2.1811149
##  [574,] 1.2120920 0.9693881
##  [575,] 1.1562814 1.8090784
##  [576,] 1.0740194 1.2768327
##  [577,] 1.2021548 0.6473793
##  [578,] 0.7883757 0.8728858
##  [579,] 1.0649965 0.7540694
##  [580,] 0.8089269 0.8263580
##  [581,] 1.1352680 0.6329921
##  [582,] 1.0144257 1.2869499
##  [583,] 0.8903511 1.9242333
##  [584,] 0.6202373 1.9254319
##  [585,] 0.7037770 0.8446951
##  [586,] 0.7826133 0.5566283
##  [587,] 1.3395504 0.7551239
##  [588,] 0.9791190 1.1367252
##  [589,] 0.6025398 0.7805509
##  [590,] 1.2197098 1.0001454
##  [591,] 0.7413648 1.0055673
##  [592,] 1.4123832 0.7682982
##  [593,] 0.7057234 1.0333538
##  [594,] 0.8910020 1.9564145
##  [595,] 1.1657615 0.6740693
##  [596,] 1.3112002 0.5140262
##  [597,] 1.9805823 0.4073261
##  [598,] 0.6949726 0.7942276
##  [599,] 0.7253542 0.3474668
##  [600,] 1.1309589 0.8429140
##  [601,] 1.4613462 1.0069939
##  [602,] 0.5447964 0.7458852
##  [603,] 0.8228005 1.1232411
##  [604,] 0.7120696 0.8573119
##  [605,] 1.0338924 1.6272995
##  [606,] 1.2301363 0.8925071
##  [607,] 1.0820828 0.6809451
##  [608,] 0.7316956 1.4934789
##  [609,] 1.1065737 0.9849202
##  [610,] 0.8032277 0.4539720
##  [611,] 0.7693680 0.8286306
##  [612,] 0.6850510 0.9841286
##  [613,] 0.9378810 1.4800436
##  [614,] 1.0796378 0.6019105
##  [615,] 0.9208241 0.7484817
##  [616,] 1.1698834 0.5438115
##  [617,] 0.7538503 0.7073729
##  [618,] 0.7064029 1.6763819
##  [619,] 1.4270821 2.1061245
##  [620,] 0.8357316 1.6294462
##  [621,] 0.6665532 1.0811663
##  [622,] 0.9743948 0.9086492
##  [623,] 1.4920758 1.0346905
##  [624,] 1.0590936 1.4603659
##  [625,] 1.0441625 1.5273194
##  [626,] 0.8291825 1.4501982
##  [627,] 1.3214314 0.6023863
##  [628,] 1.0315628 0.5608889
##  [629,] 0.7787733 0.3923391
##  [630,] 1.1647764 0.8501288
##  [631,] 0.7245886 0.4309669
##  [632,] 1.2750356 1.7039699
##  [633,] 0.9065931 1.2795612
##  [634,] 0.9703932 0.8294686
##  [635,] 0.8610523 0.6872401
##  [636,] 1.1467637 1.7562516
##  [637,] 1.1520756 0.9555800
##  [638,] 0.8580547 0.6559230
##  [639,] 0.5612803 1.1245826
##  [640,] 1.0186715 1.4541144
##  [641,] 1.3027007 0.7718160
##  [642,] 1.1228668 0.7246112
##  [643,] 0.8921727 0.7397660
##  [644,] 1.0223330 2.0042494
##  [645,] 0.9716527 1.7441632
##  [646,] 1.1683312 0.4459923
##  [647,] 1.1443044 0.4479558
##  [648,] 0.6948759 1.0196910
##  [649,] 0.8426038 0.6441466
##  [650,] 0.9512364 0.4164697
##  [651,] 1.2045461 0.5536741
##  [652,] 0.8094372 2.4736140
##  [653,] 1.2356751 0.4941406
##  [654,] 1.5679220 1.0473622
##  [655,] 1.2420237 1.1511146
##  [656,] 0.8546784 0.7577945
##  [657,] 0.5760619 0.6135417
##  [658,] 0.7650887 0.7787242
##  [659,] 1.1744308 1.1078548
##  [660,] 1.9931677 0.6598321
##  [661,] 1.3463504 1.0933320
##  [662,] 0.9520636 0.9112730
##  [663,] 0.7850708 0.4105222
##  [664,] 0.8216188 0.9194458
##  [665,] 1.3961985 0.7174194
##  [666,] 1.0285769 1.1941373
##  [667,] 1.1546857 2.2179354
##  [668,] 1.2931731 0.9001722
##  [669,] 0.6951781 2.0105002
##  [670,] 1.2042515 1.4391916
##  [671,] 1.0317114 3.9181457
##  [672,] 0.7093663 0.8819896
##  [673,] 0.7968897 0.8580593
##  [674,] 0.7882577 1.5039900
##  [675,] 1.0180251 0.5365722
##  [676,] 0.9857147 1.0669214
##  [677,] 1.1908348 0.4672265
##  [678,] 1.0021360 0.8802634
##  [679,] 0.7609059 0.8021705
##  [680,] 1.1964228 1.2396225
##  [681,] 1.0248142 1.0068685
##  [682,] 0.6324376 1.3505663
##  [683,] 0.6649608 1.3339982
##  [684,] 1.0034428 1.2902211
##  [685,] 0.7572577 1.0064582
##  [686,] 0.6657153 0.6511263
##  [687,] 1.1777773 1.3965310
##  [688,] 0.9273487 0.8762523
##  [689,] 0.6797241 0.9494285
##  [690,] 0.6381985 0.4090176
##  [691,] 0.8839093 0.6213613
##  [692,] 0.8738794 0.7108884
##  [693,] 1.7954783 1.2657884
##  [694,] 1.0271121 0.7115419
##  [695,] 0.8447774 0.7694020
##  [696,] 0.7040189 0.7588520
##  [697,] 0.7545213 1.4836176
##  [698,] 1.1983288 1.1584078
##  [699,] 0.5241167 1.1465265
##  [700,] 0.9051353 0.7468282
##  [701,] 1.0773100 0.7913868
##  [702,] 0.5066276 1.2189371
##  [703,] 0.7242308 0.5956732
##  [704,] 0.5553916 1.1203123
##  [705,] 0.8195505 1.0390261
##  [706,] 1.4482730 1.4378739
##  [707,] 1.2822367 1.1996377
##  [708,] 1.0805379 1.5618982
##  [709,] 1.6268470 1.2147666
##  [710,] 0.8469922 0.8632802
##  [711,] 1.0593349 0.6579064
##  [712,] 0.8183309 0.4408237
##  [713,] 1.1465665 0.7532787
##  [714,] 0.6893742 1.2367586
##  [715,] 0.8482768 0.7485128
##  [716,] 0.7843643 1.1899951
##  [717,] 1.2105570 0.4710845
##  [718,] 1.1213919 1.3359200
##  [719,] 0.7101799 0.4226685
##  [720,] 0.9336594 1.8587015
##  [721,] 0.6412552 0.4275971
##  [722,] 1.1733527 1.1822720
##  [723,] 0.7408729 2.8702074
##  [724,] 0.8001790 0.7410009
##  [725,] 0.6681008 0.4139786
##  [726,] 0.7643993 1.5883684
##  [727,] 0.9927759 0.4284440
##  [728,] 0.8379628 1.1352222
##  [729,] 0.6253235 2.1876394
##  [730,] 0.9959543 0.3284356
##  [731,] 1.0021495 1.2052918
##  [732,] 0.5465298 0.3785219
##  [733,] 0.9286447 0.3992927
##  [734,] 0.7330960 0.3830655
##  [735,] 0.7971480 1.2628457
##  [736,] 1.3546272 0.4054788
##  [737,] 0.8307307 0.4852018
##  [738,] 1.3401579 0.5073067
##  [739,] 1.3250982 0.8387957
##  [740,] 1.4121633 0.7509234
##  [741,] 0.6378930 0.7595790
##  [742,] 1.1048584 0.8119045
##  [743,] 0.6374565 2.0310758
##  [744,] 0.5234974 0.8253865
##  [745,] 0.7821904 0.6226976
##  [746,] 0.8367577 1.9810940
##  [747,] 0.8491693 1.6332136
##  [748,] 1.2278275 1.1139212
##  [749,] 1.4219810 0.5069426
##  [750,] 0.8935361 0.6991112
##  [751,] 0.5614884 0.6463152
##  [752,] 1.8161872 0.9221934
##  [753,] 0.7406811 0.6638283
##  [754,] 1.2575691 1.3084464
##  [755,] 1.1693230 0.7590398
##  [756,] 1.1664288 0.6156522
##  [757,] 1.4666693 1.0656968
##  [758,] 0.4639836 0.6200447
##  [759,] 0.6501347 1.6677288
##  [760,] 0.6954873 0.5429889
##  [761,] 0.7324164 0.8906764
##  [762,] 0.9654135 0.7677823
##  [763,] 0.9172378 0.6735571
##  [764,] 0.7636772 1.0369433
##  [765,] 0.7328536 0.5242606
##  [766,] 0.8996562 1.5323415
##  [767,] 1.1573999 1.0276826
##  [768,] 1.4405026 2.2427999
##  [769,] 1.0509702 0.9055893
##  [770,] 0.8208643 1.6760360
##  [771,] 1.0950852 1.5840049
##  [772,] 1.6926684 0.7923547
##  [773,] 0.9077760 1.3748379
##  [774,] 1.3402836 1.2316229
##  [775,] 1.3964924 1.8724052
##  [776,] 0.9084082 0.9170238
##  [777,] 0.7574924 1.4560753
##  [778,] 0.7691529 0.6836289
##  [779,] 1.2537253 0.2650681
##  [780,] 1.2325171 1.3835652
##  [781,] 0.8625166 0.5360766
##  [782,] 1.0355473 1.2418672
##  [783,] 0.8722917 1.5831776
##  [784,] 1.9953528 0.4969870
##  [785,] 1.6966442 1.3406037
##  [786,] 1.8655449 0.6712855
##  [787,] 1.1312105 0.6995456
##  [788,] 1.1802739 0.9249234
##  [789,] 1.0049005 0.7863006
##  [790,] 0.9281978 0.8929807
##  [791,] 1.8160559 1.3401870
##  [792,] 1.3095076 0.7524864
##  [793,] 0.5101908 0.6089221
##  [794,] 1.2697449 0.8106857
##  [795,] 1.5416143 1.1345069
##  [796,] 0.8243539 0.8424907
##  [797,] 0.9745737 0.4679632
##  [798,] 0.6087777 0.5254210
##  [799,] 1.5506258 1.2022679
##  [800,] 0.7962194 0.9796665
##  [801,] 1.6669112 0.4963791
##  [802,] 0.5625172 0.9594555
##  [803,] 0.9132914 0.5822076
##  [804,] 1.0049876 0.9282966
##  [805,] 1.0115477 1.6273054
##  [806,] 0.9010601 1.4174974
##  [807,] 0.9161251 0.6474500
##  [808,] 0.9039248 0.7799207
##  [809,] 1.3145261 0.4656552
##  [810,] 1.2269914 1.4080171
##  [811,] 1.2562464 0.9251192
##  [812,] 1.8915965 1.1680769
##  [813,] 0.8150862 0.9381150
##  [814,] 1.5116424 1.2966575
##  [815,] 1.0021994 0.2631473
##  [816,] 0.9181216 0.6688342
##  [817,] 0.9867515 1.5647334
##  [818,] 1.0772697 1.0856121
##  [819,] 0.8699965 0.7593288
##  [820,] 1.1151674 1.4353631
##  [821,] 0.6367493 0.9875731
##  [822,] 1.3077656 1.2640421
##  [823,] 0.9581895 1.6516530
##  [824,] 0.8065693 0.4989043
##  [825,] 1.0987113 0.5623038
##  [826,] 1.3662461 0.9943837
##  [827,] 1.0713426 0.5969084
##  [828,] 0.7483140 0.4525153
##  [829,] 0.7491190 1.3926748
##  [830,] 0.9631771 1.1803139
##  [831,] 1.0649647 0.5441846
##  [832,] 1.1374082 0.6863859
##  [833,] 1.0073601 0.5626033
##  [834,] 1.1569416 1.6617747
##  [835,] 0.7154024 2.0817870
##  [836,] 0.7435282 0.9811627
##  [837,] 1.4223098 0.8171884
##  [838,] 0.8697118 0.6116146
##  [839,] 0.7832292 0.9057461
##  [840,] 0.7724555 0.7299136
##  [841,] 0.8958912 0.6345570
##  [842,] 0.5314561 1.2213563
##  [843,] 0.6562989 0.4821534
##  [844,] 0.7612652 1.2584179
##  [845,] 0.9200519 0.9714014
##  [846,] 0.8125093 0.9684437
##  [847,] 1.6710094 0.9485966
##  [848,] 1.0850643 1.1765769
##  [849,] 1.2275967 0.6718536
##  [850,] 0.9351452 1.5116728
##  [851,] 0.8127168 1.2101687
##  [852,] 0.9696861 0.8204855
##  [853,] 1.4674366 1.0763140
##  [854,] 1.0603570 1.1956235
##  [855,] 1.0680558 1.4749981
##  [856,] 0.6158830 0.5232306
##  [857,] 0.8227029 0.9208324
##  [858,] 1.0830914 1.4437282
##  [859,] 1.0067564 0.8162534
##  [860,] 1.0764050 0.6086180
##  [861,] 0.6842001 0.9646584
##  [862,] 0.8145499 0.6118680
##  [863,] 0.9695497 3.2794185
##  [864,] 1.2039410 1.6552519
##  [865,] 0.5999775 1.2078962
##  [866,] 1.0784232 1.2968340
##  [867,] 1.0823058 0.7382051
##  [868,] 1.2244732 0.5200907
##  [869,] 0.8275127 1.1084480
##  [870,] 1.5118006 0.8699999
##  [871,] 0.8770308 0.9371273
##  [872,] 0.8361844 1.6526203
##  [873,] 0.5785214 1.5036071
##  [874,] 0.7585728 0.5986714
##  [875,] 1.4917113 0.7426994
##  [876,] 0.8894087 0.3944909
##  [877,] 0.6439860 0.7028637
##  [878,] 1.1445386 0.5938713
##  [879,] 2.2910160 1.1545044
##  [880,] 1.5221842 0.2826215
##  [881,] 0.8045311 0.6875487
##  [882,] 0.6524053 0.8337001
##  [883,] 0.6543359 0.4600478
##  [884,] 0.9547024 1.0165738
##  [885,] 1.3933974 0.3088885
##  [886,] 0.6330600 1.7131940
##  [887,] 0.9705520 0.3195443
##  [888,] 1.4722196 0.6095879
##  [889,] 1.1547081 0.5265887
##  [890,] 1.5585599 0.6561791
##  [891,] 1.2368566 0.4149984
##  [892,] 0.8964252 0.3880211
##  [893,] 0.9896127 0.5198439
##  [894,] 1.0537558 0.5602018
##  [895,] 1.1958992 0.9234252
##  [896,] 0.7981722 1.0170539
##  [897,] 1.0852074 0.3888292
##  [898,] 0.6500923 0.6759186
##  [899,] 1.5189774 0.4094401
##  [900,] 1.0747303 1.3779871
##  [901,] 0.8697099 0.7150058
##  [902,] 1.5691800 0.9224088
##  [903,] 0.7283193 1.0247689
##  [904,] 0.9775702 1.0024914
##  [905,] 0.9388849 0.6217100
##  [906,] 0.8824637 0.7399397
##  [907,] 0.9427994 1.3217052
##  [908,] 1.0603842 1.1019794
##  [909,] 0.5748232 1.2165576
##  [910,] 1.0605568 1.1636853
##  [911,] 1.0393630 0.6362192
##  [912,] 1.5623116 0.6018331
##  [913,] 1.5026172 2.2984852
##  [914,] 0.8263459 0.4110551
##  [915,] 0.6343374 1.1003332
##  [916,] 1.2881780 0.7489181
##  [917,] 0.7659950 0.8373192
##  [918,] 0.7913584 1.2734419
##  [919,] 1.3279580 1.2074719
##  [920,] 1.0559873 2.4372776
##  [921,] 1.1951463 0.3938270
##  [922,] 0.7364159 0.7797079
##  [923,] 1.3131855 0.5392406
##  [924,] 0.9423224 1.0027545
##  [925,] 0.7120228 0.5328109
##  [926,] 0.8406394 1.7414532
##  [927,] 0.9545558 2.3663881
##  [928,] 1.2230947 1.2472972
##  [929,] 1.0394050 1.3906139
##  [930,] 0.9368226 1.3892652
##  [931,] 0.6285138 0.3485173
##  [932,] 0.8480085 0.7350718
##  [933,] 0.7861981 0.7183253
##  [934,] 1.0104593 0.7293383
##  [935,] 0.9749066 1.2268274
##  [936,] 1.0992632 1.1199484
##  [937,] 1.3440497 1.0258851
##  [938,] 0.8754936 0.4011545
##  [939,] 0.8811123 0.5953963
##  [940,] 1.4834494 0.3355002
##  [941,] 0.7787116 1.5418459
##  [942,] 0.9552765 1.1611663
##  [943,] 1.3169831 0.8738975
##  [944,] 1.2977942 1.8766458
##  [945,] 0.5351284 0.5725078
##  [946,] 0.8388678 1.3400165
##  [947,] 1.3762028 0.9970174
##  [948,] 1.2776679 0.5739520
##  [949,] 1.0034007 0.4268444
##  [950,] 0.9439951 0.9278053
##  [951,] 0.9699248 0.5606782
##  [952,] 0.7408866 1.1899901
##  [953,] 0.8976722 0.8785407
##  [954,] 0.7868743 0.4958047
##  [955,] 0.9136573 0.7831278
##  [956,] 1.2397495 0.7289700
##  [957,] 0.9733396 1.2733582
##  [958,] 0.8674982 0.2810900
##  [959,] 1.1840797 0.8920043
##  [960,] 0.9703181 1.9685399
##  [961,] 0.8652151 1.1275761
##  [962,] 0.8439949 1.0028363
##  [963,] 0.6943382 1.8512071
##  [964,] 1.0631502 0.7213011
##  [965,] 1.3759779 0.5877042
##  [966,] 1.4472004 1.3340908
##  [967,] 0.8641971 1.2698997
##  [968,] 0.7750231 0.8455200
##  [969,] 1.2331331 0.7435669
##  [970,] 0.6943393 0.8932211
##  [971,] 0.8747194 0.7971075
##  [972,] 0.6798433 3.8661013
##  [973,] 0.8472361 1.8105810
##  [974,] 1.0856201 0.7411371
##  [975,] 0.6455898 0.7768880
##  [976,] 0.6706382 0.5287158
##  [977,] 0.9071974 0.4074187
##  [978,] 0.7443147 0.5092617
##  [979,] 0.8419989 0.6292002
##  [980,] 1.4108531 0.8726944
##  [981,] 1.2984487 0.6172672
##  [982,] 0.9260111 0.5170337
##  [983,] 0.6591741 0.8104121
##  [984,] 0.6150512 1.6165970
##  [985,] 1.7543746 0.9574870
##  [986,] 1.2964533 0.7048781
##  [987,] 1.1294230 0.7929182
##  [988,] 0.9202047 1.8262635
##  [989,] 1.2874922 2.1161221
##  [990,] 0.7696262 0.6261864
##  [991,] 0.6335608 1.3521650
##  [992,] 1.2517451 0.6957591
##  [993,] 0.9426583 0.6213873
##  [994,] 0.8954314 1.1472828
##  [995,] 1.4782895 0.7523562
##  [996,] 0.9186769 0.9291405
##  [997,] 1.2368775 0.9661531
##  [998,] 0.6015389 0.5119626
##  [999,] 1.1062771 0.3341857
## 
## $model.matrix
##     (Intercept) format_ITS_L6$Group11 format_ITS_L6$Group12
## 1             1                    -1                    -1
## 2             1                     1                     0
## 3             1                     0                     0
## 4             1                     0                     1
## 5             1                    -1                    -1
## 6             1                     1                     0
## 7             1                     0                     0
## 8             1                     0                     1
## 9             1                    -1                    -1
## 10            1                     1                     0
## 11            1                     0                     0
## 12            1                     0                     1
## 13            1                    -1                    -1
## 14            1                     1                     0
## 15            1                     0                     0
## 16            1                     0                     1
## 17            1                    -1                    -1
## 18            1                     1                     0
## 19            1                     0                     0
## 20            1                     0                     1
## 21            1                    -1                    -1
## 22            1                     1                     0
## 23            1                     0                     0
## 24            1                     0                     1
## 25            1                    -1                    -1
## 26            1                     1                     0
## 27            1                     0                     0
## 28            1                     0                     1
## 29            1                    -1                    -1
## 30            1                     1                     0
## 31            1                     0                     0
## 32            1                     0                     1
## 33            1                    -1                    -1
## 34            1                     1                     0
## 35            1                     0                     0
## 36            1                     0                     1
## 37            1                    -1                    -1
## 38            1                     1                     0
## 39            1                     0                     0
## 40            1                     0                     1
## 41            1                    -1                    -1
## 42            1                     1                     0
## 43            1                     0                     0
## 44            1                     0                     1
## 45            1                    -1                    -1
## 46            1                     1                     0
## 47            1                     0                     0
## 48            1                     0                     1
## 49            1                    -1                    -1
## 50            1                     1                     0
## 51            1                     0                     0
## 52            1                     0                     1
## 53            1                    -1                    -1
## 54            1                     1                     0
## 55            1                     0                     0
## 56            1                     0                     1
## 57            1                    -1                    -1
## 58            1                     1                     0
## 59            1                     0                     0
## 60            1                     0                     1
## 61            1                    -1                    -1
## 62            1                     1                     0
## 63            1                     0                     0
## 64            1                     0                     1
## 65            1                    -1                    -1
## 66            1                     1                     0
## 67            1                     0                     0
## 68            1                     0                     1
## 69            1                    -1                    -1
## 70            1                     1                     0
## 71            1                     0                     0
## 72            1                     0                     1
## 73            1                    -1                    -1
## 74            1                     1                     0
## 75            1                     0                     0
## 76            1                     0                     1
## 77            1                    -1                    -1
## 78            1                     1                     0
## 79            1                     0                     0
## 80            1                     0                     1
## 81            1                    -1                    -1
## 82            1                     1                     0
## 83            1                     0                     0
## 84            1                     0                     1
## 85            1                    -1                    -1
## 86            1                     1                     0
## 87            1                     0                     0
## 88            1                     0                     1
## 89            1                    -1                    -1
## 90            1                     1                     0
## 91            1                     0                     0
## 92            1                     0                     1
## 93            1                    -1                    -1
## 94            1                     1                     0
## 95            1                     0                     0
## 96            1                     0                     1
## 97            1                    -1                    -1
## 98            1                     1                     0
## 99            1                     0                     0
## 100           1                     0                     1
## 101           1                    -1                    -1
## 102           1                     1                     0
## 103           1                     0                     0
## 104           1                     0                     1
## 105           1                    -1                    -1
## 106           1                     1                     0
## 107           1                     0                     0
## 108           1                     0                     1
## 109           1                    -1                    -1
## 110           1                     1                     0
## 111           1                     0                     0
## 112           1                     0                     1
## 113           1                    -1                    -1
## 114           1                     1                     0
## 115           1                     0                     0
## 116           1                     0                     1
## 117           1                    -1                    -1
## 118           1                     1                     0
## 119           1                     0                     0
## 120           1                     0                     1
## 121           1                    -1                    -1
## 122           1                     1                     0
## 123           1                     0                     0
## 124           1                     0                     1
## 125           1                    -1                    -1
## 126           1                     1                     0
## 127           1                     0                     0
## 128           1                     0                     1
## 129           1                    -1                    -1
## 130           1                     1                     0
## 131           1                     0                     0
## 132           1                     0                     1
## 133           1                    -1                    -1
## 134           1                     1                     0
## 135           1                     0                     0
## 136           1                     0                     1
## 137           1                    -1                    -1
## 138           1                     1                     0
## 139           1                     0                     0
## 140           1                     0                     1
## 141           1                    -1                    -1
## 142           1                     1                     0
## 143           1                     0                     0
## 144           1                     0                     1
## 145           1                    -1                    -1
## 146           1                     1                     0
## 147           1                     0                     0
## 148           1                     0                     1
## 149           1                    -1                    -1
## 150           1                     1                     0
## 151           1                     0                     0
## 152           1                     0                     1
## 153           1                    -1                    -1
## 154           1                     1                     0
## 155           1                     0                     0
## 156           1                     0                     1
## 157           1                    -1                    -1
## 158           1                     1                     0
## 159           1                     0                     0
## 160           1                     0                     1
## 161           1                    -1                    -1
## 162           1                     1                     0
## 163           1                     0                     0
## 164           1                     0                     1
## 165           1                    -1                    -1
## 166           1                     1                     0
## 167           1                     0                     0
## 168           1                     0                     1
## 169           1                    -1                    -1
## 170           1                     1                     0
## 171           1                     0                     0
## 172           1                     0                     1
## 173           1                    -1                    -1
## 174           1                     1                     0
## 175           1                     0                     0
## 176           1                     0                     1
## 177           1                    -1                    -1
## 178           1                     1                     0
## 179           1                     0                     0
## 180           1                     0                     1
## 181           1                    -1                    -1
## 182           1                     1                     0
## 183           1                     0                     0
## 184           1                     0                     1
## 185           1                    -1                    -1
## 186           1                     1                     0
## 187           1                     0                     0
## 188           1                     0                     1
## 189           1                    -1                    -1
## 190           1                     1                     0
## 191           1                     0                     0
## 192           1                     0                     1
## 193           1                    -1                    -1
## 194           1                     1                     0
## 195           1                     0                     0
## 196           1                     0                     1
## 197           1                    -1                    -1
## 198           1                     1                     0
## 199           1                     0                     0
## 200           1                     0                     1
## 201           1                    -1                    -1
## 202           1                     1                     0
## 203           1                     0                     0
## 204           1                     0                     1
## 205           1                    -1                    -1
## 206           1                     1                     0
## 207           1                     0                     0
## 208           1                     0                     1
## 209           1                    -1                    -1
## 210           1                     1                     0
## 211           1                     0                     0
## 212           1                     0                     1
## 213           1                    -1                    -1
## 214           1                     1                     0
## 215           1                     0                     0
## 216           1                     0                     1
## 217           1                    -1                    -1
## 218           1                     1                     0
## 219           1                     0                     0
## 220           1                     0                     1
## 221           1                    -1                    -1
## 222           1                     1                     0
## 223           1                     0                     0
## 224           1                     0                     1
## 225           1                    -1                    -1
## 226           1                     1                     0
## 227           1                     0                     0
## 228           1                     0                     1
## 229           1                    -1                    -1
## 230           1                     1                     0
## 231           1                     0                     0
## 232           1                     0                     1
## 233           1                    -1                    -1
## 234           1                     1                     0
## 235           1                     0                     0
## 236           1                     0                     1
## 237           1                    -1                    -1
## 238           1                     1                     0
## 239           1                     0                     0
## 240           1                     0                     1
## 241           1                    -1                    -1
## 242           1                     1                     0
## 243           1                     0                     0
## 244           1                     0                     1
## 245           1                    -1                    -1
## 246           1                     1                     0
## 247           1                     0                     0
## 248           1                     0                     1
## 249           1                    -1                    -1
## 250           1                     1                     0
## 251           1                     0                     0
## 252           1                     0                     1
## 253           1                    -1                    -1
## 254           1                     1                     0
## 255           1                     0                     0
## 256           1                     0                     1
## 257           1                    -1                    -1
## 258           1                     1                     0
## 259           1                     0                     0
## 260           1                     0                     1
## 261           1                    -1                    -1
## 262           1                     1                     0
## 263           1                     0                     0
## 264           1                     0                     1
## 265           1                    -1                    -1
## 266           1                     1                     0
## 267           1                     0                     0
## 268           1                     0                     1
## 269           1                    -1                    -1
## 270           1                     1                     0
## 271           1                     0                     0
## 272           1                     0                     1
## 273           1                    -1                    -1
## 274           1                     1                     0
## 275           1                     0                     0
## 276           1                     0                     1
## 277           1                    -1                    -1
## 278           1                     1                     0
## 279           1                     0                     0
## 280           1                     0                     1
## 281           1                    -1                    -1
## 282           1                     1                     0
## 283           1                     0                     0
## 284           1                     0                     1
## 285           1                    -1                    -1
## 286           1                     1                     0
## 287           1                     0                     0
## 288           1                     0                     1
## 289           1                    -1                    -1
## 290           1                     1                     0
## 291           1                     0                     0
## 292           1                     0                     1
## 293           1                    -1                    -1
## 294           1                     1                     0
## 295           1                     0                     0
## 296           1                     0                     1
## 297           1                    -1                    -1
## 298           1                     1                     0
## 299           1                     0                     0
## 300           1                     0                     1
## 301           1                    -1                    -1
## 302           1                     1                     0
## 303           1                     0                     0
## 304           1                     0                     1
## 305           1                    -1                    -1
## 306           1                     1                     0
## 307           1                     0                     0
## 308           1                     0                     1
## 309           1                    -1                    -1
## 310           1                     1                     0
## 311           1                     0                     0
## 312           1                     0                     1
## 313           1                    -1                    -1
## 314           1                     1                     0
## 315           1                     0                     0
## 316           1                     0                     1
## 317           1                    -1                    -1
## 318           1                     1                     0
## 319           1                     0                     0
## 320           1                     0                     1
##     format_ITS_L6$Group13 dph
## 1                      -1   1
## 2                       0   1
## 3                       1   1
## 4                       0   1
## 5                      -1   1
## 6                       0   1
## 7                       1   1
## 8                       0   1
## 9                      -1   1
## 10                      0   1
## 11                      1   1
## 12                      0   1
## 13                     -1   1
## 14                      0   1
## 15                      1   1
## 16                      0   1
## 17                     -1   1
## 18                      0   1
## 19                      1   1
## 20                      0   1
## 21                     -1   1
## 22                      0   1
## 23                      1   1
## 24                      0   1
## 25                     -1   1
## 26                      0   1
## 27                      1   1
## 28                      0   1
## 29                     -1   1
## 30                      0   1
## 31                      1   1
## 32                      0   1
## 33                     -1   1
## 34                      0   1
## 35                      1   1
## 36                      0   1
## 37                     -1   1
## 38                      0   1
## 39                      1   1
## 40                      0   1
## 41                     -1   4
## 42                      0   4
## 43                      1   4
## 44                      0   4
## 45                     -1   4
## 46                      0   4
## 47                      1   4
## 48                      0   4
## 49                     -1   4
## 50                      0   4
## 51                      1   4
## 52                      0   4
## 53                     -1   4
## 54                      0   4
## 55                      1   4
## 56                      0   4
## 57                     -1   4
## 58                      0   4
## 59                      1   4
## 60                      0   4
## 61                     -1   4
## 62                      0   4
## 63                      1   4
## 64                      0   4
## 65                     -1   4
## 66                      0   4
## 67                      1   4
## 68                      0   4
## 69                     -1   4
## 70                      0   4
## 71                      1   4
## 72                      0   4
## 73                     -1   4
## 74                      0   4
## 75                      1   4
## 76                      0   4
## 77                     -1   4
## 78                      0   4
## 79                      1   4
## 80                      0   4
## 81                     -1   7
## 82                      0   7
## 83                      1   7
## 84                      0   7
## 85                     -1   7
## 86                      0   7
## 87                      1   7
## 88                      0   7
## 89                     -1   7
## 90                      0   7
## 91                      1   7
## 92                      0   7
## 93                     -1   7
## 94                      0   7
## 95                      1   7
## 96                      0   7
## 97                     -1   7
## 98                      0   7
## 99                      1   7
## 100                     0   7
## 101                    -1   7
## 102                     0   7
## 103                     1   7
## 104                     0   7
## 105                    -1   7
## 106                     0   7
## 107                     1   7
## 108                     0   7
## 109                    -1   7
## 110                     0   7
## 111                     1   7
## 112                     0   7
## 113                    -1   7
## 114                     0   7
## 115                     1   7
## 116                     0   7
## 117                    -1   7
## 118                     0   7
## 119                     1   7
## 120                     0   7
## 121                    -1  14
## 122                     0  14
## 123                     1  14
## 124                     0  14
## 125                    -1  14
## 126                     0  14
## 127                     1  14
## 128                     0  14
## 129                    -1  14
## 130                     0  14
## 131                     1  14
## 132                     0  14
## 133                    -1  14
## 134                     0  14
## 135                     1  14
## 136                     0  14
## 137                    -1  14
## 138                     0  14
## 139                     1  14
## 140                     0  14
## 141                    -1  14
## 142                     0  14
## 143                     1  14
## 144                     0  14
## 145                    -1  14
## 146                     0  14
## 147                     1  14
## 148                     0  14
## 149                    -1  14
## 150                     0  14
## 151                     1  14
## 152                     0  14
## 153                    -1  14
## 154                     0  14
## 155                     1  14
## 156                     0  14
## 157                    -1  14
## 158                     0  14
## 159                     1  14
## 160                     0  14
## 161                    -1  21
## 162                     0  21
## 163                     1  21
## 164                     0  21
## 165                    -1  21
## 166                     0  21
## 167                     1  21
## 168                     0  21
## 169                    -1  21
## 170                     0  21
## 171                     1  21
## 172                     0  21
## 173                    -1  21
## 174                     0  21
## 175                     1  21
## 176                     0  21
## 177                    -1  21
## 178                     0  21
## 179                     1  21
## 180                     0  21
## 181                    -1  21
## 182                     0  21
## 183                     1  21
## 184                     0  21
## 185                    -1  21
## 186                     0  21
## 187                     1  21
## 188                     0  21
## 189                    -1  21
## 190                     0  21
## 191                     1  21
## 192                     0  21
## 193                    -1  21
## 194                     0  21
## 195                     1  21
## 196                     0  21
## 197                    -1  21
## 198                     0  21
## 199                     1  21
## 200                     0  21
## 201                    -1  28
## 202                     0  28
## 203                     1  28
## 204                     0  28
## 205                    -1  28
## 206                     0  28
## 207                     1  28
## 208                     0  28
## 209                    -1  28
## 210                     0  28
## 211                     1  28
## 212                     0  28
## 213                    -1  28
## 214                     0  28
## 215                     1  28
## 216                     0  28
## 217                    -1  28
## 218                     0  28
## 219                     1  28
## 220                     0  28
## 221                    -1  28
## 222                     0  28
## 223                     1  28
## 224                     0  28
## 225                    -1  28
## 226                     0  28
## 227                     1  28
## 228                     0  28
## 229                    -1  28
## 230                     0  28
## 231                     1  28
## 232                     0  28
## 233                    -1  28
## 234                     0  28
## 235                     1  28
## 236                     0  28
## 237                    -1  28
## 238                     0  28
## 239                     1  28
## 240                     0  28
## 241                    -1  35
## 242                     0  35
## 243                     1  35
## 244                     0  35
## 245                    -1  35
## 246                     0  35
## 247                     1  35
## 248                     0  35
## 249                    -1  35
## 250                     0  35
## 251                     1  35
## 252                     0  35
## 253                    -1  35
## 254                     0  35
## 255                     1  35
## 256                     0  35
## 257                    -1  35
## 258                     0  35
## 259                     1  35
## 260                     0  35
## 261                    -1  35
## 262                     0  35
## 263                     1  35
## 264                     0  35
## 265                    -1  35
## 266                     0  35
## 267                     1  35
## 268                     0  35
## 269                    -1  35
## 270                     0  35
## 271                     1  35
## 272                     0  35
## 273                    -1  35
## 274                     0  35
## 275                     1  35
## 276                     0  35
## 277                    -1  35
## 278                     0  35
## 279                     1  35
## 280                     0  35
## 281                    -1  42
## 282                     0  42
## 283                     1  42
## 284                     0  42
## 285                    -1  42
## 286                     0  42
## 287                     1  42
## 288                     0  42
## 289                    -1  42
## 290                     0  42
## 291                     1  42
## 292                     0  42
## 293                    -1  42
## 294                     0  42
## 295                     1  42
## 296                     0  42
## 297                    -1  42
## 298                     0  42
## 299                     1  42
## 300                     0  42
## 301                    -1  42
## 302                     0  42
## 303                     1  42
## 304                     0  42
## 305                    -1  42
## 306                     0  42
## 307                     1  42
## 308                     0  42
## 309                    -1  42
## 310                     0  42
## 311                     1  42
## 312                     0  42
## 313                    -1  42
## 314                     0  42
## 315                     1  42
## 316                     0  42
## 317                    -1  42
## 318                     0  42
## 319                     1  42
## 320                     0  42
## 
## $terms
## format_ITS_L6[, 1:603] ~ format_ITS_L6$Group1 + dph
## attr(,"variables")
## list(format_ITS_L6[, 1:603], format_ITS_L6$Group1, dph)
## attr(,"factors")
##                        format_ITS_L6$Group1 dph
## format_ITS_L6[, 1:603]                    0   0
## format_ITS_L6$Group1                      1   0
## dph                                       0   1
## attr(,"term.labels")
## [1] "format_ITS_L6$Group1" "dph"                 
## attr(,"order")
## [1] 1 1
## attr(,"intercept")
## [1] 1
## attr(,"response")
## [1] 1
## attr(,".Environment")
## <environment: R_GlobalEnv>
## 
## attr(,"class")
## [1] "adonis"
set.seed(1234)
adonis(format_ITS_L6_AA[,1:603] ~ format_ITS_L6_AA$Group1 + dph)
## 'adonis' will be deprecated: use 'adonis2' instead
## $aov.tab
## Permutation: free
## Number of permutations: 999
## 
## Terms added sequentially (first to last)
## 
##                          Df SumsOfSqs MeanSqs F.Model      R2 Pr(>F)    
## format_ITS_L6_AA$Group1   3    14.141  4.7138  14.329 0.11674  0.001 ***
## dph                       1     3.366  3.3662  10.232 0.02779  0.001 ***
## Residuals               315   103.628  0.3290         0.85547           
## Total                   319   121.135                 1.00000           
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## $call
## adonis(formula = format_ITS_L6_AA[, 1:603] ~ format_ITS_L6_AA$Group1 + 
##     dph)
## 
## $coefficients
##                                 X__     X__.1    Diplodia Lasiodiplodia
## (Intercept)               4367768.3  834141.6   2.1921395     1728.2022
## format_ITS_L6_AA$Group11 -2136548.2 -434051.0 -15.8232611     -707.9896
## format_ITS_L6_AA$Group12 -1928938.8 -176225.6 -15.8232611     -656.3975
## format_ITS_L6_AA$Group13  1011311.7  568190.2 -15.8232611     -707.9896
## dph                       -111644.4  -19806.2   0.7174275      -53.6954
##                          Macrophomina unidentified      X__.2 Arthrocatena
## (Intercept)                163.163218   2458.82752  776734.97    -766.0183
## format_ITS_L6_AA$Group11   -59.922107  -1125.21650 -445240.28    2011.3835
## format_ITS_L6_AA$Group12   179.766320  -1152.89566 -489679.18    -610.1318
## format_ITS_L6_AA$Group13   -59.922107  -1152.89566  497561.80    -700.6259
## dph                         -5.433743    -68.73326  -14329.26      77.1918
##                          Cladosporium Rachicladosporium Dissoconium Acrodontium
## (Intercept)                21157204.5        -6020.0897   61.772571   222.49088
## format_ITS_L6_AA$Group11  -11197826.7        11455.9630  -22.686134 -1579.28924
## format_ITS_L6_AA$Group12  -11600580.3        -1411.7817   41.383308 -1579.28924
## format_ITS_L6_AA$Group13   17514518.6        -5022.0906    3.988960  4731.30923
## dph                         -488176.5          581.1674   -2.057181    71.41044
##                          Cercospora   Septoria Sphaerulina Zasmidium
## (Intercept)              122292.760  5923.3067  146.236096 -263.5260
## format_ITS_L6_AA$Group11 -67111.018 -3356.7131  -53.705578  -61.9197
## format_ITS_L6_AA$Group12 -66436.385 -3160.8607  139.678414 -244.8286
## format_ITS_L6_AA$Group13 171114.341  7936.9622  -53.705578  551.5770
## dph                       -2902.313  -135.0839   -4.870027   26.7555
##                          Recurvomyces unidentified.1 Aureobasidium   Coniozyma
## (Intercept)                2092.06972      7397.8634    258181.500  1299.27204
## format_ITS_L6_AA$Group11   -961.42465     -2985.7760   -202500.014 -1695.30538
## format_ITS_L6_AA$Group12  -1010.36254     -3181.6673     -8756.021 -1669.74465
## format_ITS_L6_AA$Group13   -867.72676     -3181.6673    303446.991 -1695.30538
## dph                         -56.93196      -221.9051     -1924.674    20.84386
##                               X__.3 Arthrographis Eremomyces      X__.4
## (Intercept)               3866.3312     76941.976   9149.164 1495858.74
## format_ITS_L6_AA$Group11 -1587.3149    -36278.473  -4251.883 -645406.22
## format_ITS_L6_AA$Group12 -1587.3149    -36371.641  -4963.103 -723594.29
## format_ITS_L6_AA$Group13 -1587.3149    -33784.188  -3501.643  111249.56
## dph                       -119.9482     -2135.281   -220.319  -39395.79
##                          Camarosporidiella      X__.5 Coniothyrium  Corynespora
## (Intercept)                     28260.8741  -68.33514   17420.2538  2025.486332
## format_ITS_L6_AA$Group11       -13071.5752 -128.57369  -14804.4928 -1944.213994
## format_ITS_L6_AA$Group12       -13071.5752  -62.43627  -12707.3307  1452.983596
## format_ITS_L6_AA$Group13       -13071.5752  319.58366    2130.7125  2435.444391
## dph                              -799.4368   10.36362    -137.1157    -4.277492
##                          Pyrenochaeta Pyrenochaetopsis      X__.6 Dictyosporium
## (Intercept)                344324.783       135262.083  9045.3758    20902.1391
## format_ITS_L6_AA$Group11  -159392.353       -70691.741 -4132.2124    -8289.7299
## format_ITS_L6_AA$Group12  -160255.521       -72759.965 -4132.2124    -9246.2434
## format_ITS_L6_AA$Group13  -152541.135        31386.137 -4132.2124    -9256.3627
## dph                         -9648.982        -3276.914  -258.5875     -612.9356
##                          unidentified.2       X__.7  Didymella Neoascochyta
## (Intercept)                  2012.92000  1647793.16  560187.60    48.943524
## format_ITS_L6_AA$Group11    -1361.37860 -1019149.11 -273908.03    25.236883
## format_ITS_L6_AA$Group12     1973.68180  -999363.73 -275672.10    48.557316
## format_ITS_L6_AA$Group13      749.07540  1429873.77   69645.57   -42.314310
## dph                           -34.29165   -29579.35  -14896.92    -0.348906
##                                Phoma Stagonosporopsis     X__.8 Aporospora
## (Intercept)               29911.2846       75951.1053  88788.94  5026.1480
## format_ITS_L6_AA$Group11 -17906.5785      -60143.6209 -45680.88 -2427.9429
## format_ITS_L6_AA$Group12 -17906.5785      -60916.0857 -46171.13 -2329.8307
## format_ITS_L6_AA$Group13  53719.7356       78079.1803 -15904.07 -2444.7970
## dph                        -631.8266        -772.3447  -2236.06  -135.8606
##                            Kalmusia Paraphaeosphaeria Pseudopithomyces
## (Intercept)              182.572164         66399.051       162331.147
## format_ITS_L6_AA$Group11 -79.760864        -30313.672      -113015.750
## format_ITS_L6_AA$Group12 -79.760864        -31251.395      -113219.812
## format_ITS_L6_AA$Group13 -79.760864         46839.414      -101065.042
## dph                       -5.411121         -1840.962        -2584.807
##                           Darksidea Lentithecium Poaceascoma      X__.9
## (Intercept)              106926.454   10882.2191   24741.977 1691.58614
## format_ITS_L6_AA$Group11 -48414.348   -4579.0878  -10213.396 1765.67244
## format_ITS_L6_AA$Group12 -49107.136   -3786.3608   -9382.811 -620.46552
## format_ITS_L6_AA$Group13 -24974.544   12646.5791   24861.683 -529.75307
## dph                       -3017.861    -331.7143    -752.753  -56.33404
##                          Heterospora Leptosphaeria  Plenodomus      X__.10
## (Intercept)                58666.685     78325.648  566197.992  2613.55450
## format_ITS_L6_AA$Group11  -27284.265    -33000.428 -252804.312 -1140.24770
## format_ITS_L6_AA$Group12  -27560.510    -47109.583 -258767.077 -1140.24770
## format_ITS_L6_AA$Group13    6238.225     24779.011    9632.982 -1140.24770
## dph                        -1635.985     -1621.621  -16044.938   -77.54246
##                          Biappendiculispora Lophiotrema Byssothecium     X__.11
## (Intercept)                      -794.58438   1474.6640    532.06293 2332.18752
## format_ITS_L6_AA$Group11         1611.11653   -662.5825   -432.47339 -960.16498
## format_ITS_L6_AA$Group12         -727.18754   -958.4797   -817.60650 -948.75668
## format_ITS_L6_AA$Group13         -277.10640   2310.0955   -817.60650 -960.16498
## dph                                80.09326    -23.0193     15.02861  -72.21171
##                          Acrocalymma Multiseptospora  Periconia     X__.12
## (Intercept)                1562.2548        5.096496  4593848.4  96165.601
## format_ITS_L6_AA$Group11   3813.3903       -1.871701 -2192710.8 -44653.598
## format_ITS_L6_AA$Group12  -3566.1598       -1.871701 -2247751.0 -43694.468
## format_ITS_L6_AA$Group13  -3566.1598       -1.018310 -1122088.8  57915.752
## dph                         105.4687       -0.169726  -123279.8  -2698.641
##                          Chaetosphaeronema Leptospora Ophiobolopsis
## (Intercept)                     23872.3220  3332.6383    1814.49774
## format_ITS_L6_AA$Group11       -11834.8361   938.5559    -449.39387
## format_ITS_L6_AA$Group12       -13392.7116 -1548.7720    -930.86316
## format_ITS_L6_AA$Group13        -7160.3400   500.3965    -930.86316
## dph                              -545.3797   -93.2795     -46.50708
##                          Ophiosphaerella  Paraphoma Phaeosphaeria Septoriella
## (Intercept)                    7153.5658  3257019.4     1406.8219   64786.960
## format_ITS_L6_AA$Group11       -722.3281 -1548898.9    -2010.2847  -29920.730
## format_ITS_L6_AA$Group12      -4755.9299 -1534287.0    -2586.0089  -29917.199
## format_ITS_L6_AA$Group13      -4829.1373   -21401.9     4657.8122  -29920.730
## dph                            -122.3383   -84785.1       72.4786   -1835.065
##                            Setophoma unidentified.3     X__.13 Alternaria
## (Intercept)               332106.719     100.849756  1012.7320    5936674
## format_ITS_L6_AA$Group11 -144982.309     -37.037329 -1091.5550   -2925788
## format_ITS_L6_AA$Group12 -153682.312      36.008197  1085.2342   -2626368
## format_ITS_L6_AA$Group13  -54771.617      19.855414  1277.8233    2365472
## dph                        -9350.432      -3.358549    13.6195    -139456
##                            Bipolaris Cochliobolus  Curvularia Dichotomophthora
## (Intercept)               33501.2733    32948.181  24005.2006       17358.4402
## format_ITS_L6_AA$Group11 -16175.3384   -13528.270 -26040.8338      -10729.0871
## format_ITS_L6_AA$Group12 -16236.0444   -13528.270 -30837.9823      -10664.3836
## format_ITS_L6_AA$Group13 -10895.7480    40580.025  25651.1474       32122.5578
## dph                        -906.5311    -1022.101    380.3705        -348.9133
##                           Exserohilum   Pleospora Stemphylium       X__.14
## (Intercept)               2351.783411  2524.74827   690.01079  4456.020332
## format_ITS_L6_AA$Group11 -2194.456428  -225.45686  -368.05941 -4523.065089
## format_ITS_L6_AA$Group12 -2203.762731  -476.23874  -279.36268 -4453.551991
## format_ITS_L6_AA$Group13  4012.018748 -1231.31573   162.49247 10628.928146
## dph                         -2.785013   -67.80997   -16.94481     3.528671
##                           Monodictys Nigrograna      X__.15   Preussia
## (Intercept)               2372.40029 10156.5090  317747.906 1731129.53
## format_ITS_L6_AA$Group11 -1040.58694 11190.0113 -147118.033 -819779.23
## format_ITS_L6_AA$Group12 -1040.58694 -3730.0038 -153550.066 -866454.20
## format_ITS_L6_AA$Group13 -1040.58694 -3730.0038 -111889.069 -304907.62
## dph                        -70.09544  -338.2371   -8567.378  -45062.52
##                           Sporormia Sporormiella Westerdykella unidentified.4
## (Intercept)               3490.9802    89887.038     209.44583     1771128.13
## format_ITS_L6_AA$Group11 -1508.6413   -37705.371   -1068.87023     -756684.05
## format_ITS_L6_AA$Group12 -1519.6577   -40990.176    -978.37613     -829730.34
## format_ITS_L6_AA$Group13 -1519.6577   -21687.590    3116.11659     -369890.71
## dph                       -103.7538    -2552.497      45.23286      -48792.43
##                          Roussoella     Torula unidentified.5 Spissiomyces
## (Intercept)              1888.79686 114.335889      160045.03   -5.5525040
## format_ITS_L6_AA$Group11 1342.94907 -61.998611      -80759.36   -0.8277341
## format_ITS_L6_AA$Group12 -797.12698 -72.490373      -81303.75   10.0702670
## format_ITS_L6_AA$Group13  251.30488 -72.490373      -39323.80   -4.6212664
## dph                       -57.45631  -2.202396       -4123.89    0.5354616
##                              X__.16 Ochroconis      X__.17     X__.18
## (Intercept)               45357.917  1066767.1  444844.699  229754.03
## format_ITS_L6_AA$Group11 -17005.625  -500376.6 -248323.948 -106202.66
## format_ITS_L6_AA$Group12 -21667.518  -458117.4 -193122.387 -112879.79
## format_ITS_L6_AA$Group13 -20599.727   196089.2  176841.777   26694.89
## dph                       -1246.863   -29047.9   -9941.559   -5985.48
##                          Cyphellophora     X__.19 Cladophialophora Coniosporium
## (Intercept)                 36431.5470 13811.6611       544.317054    445631.58
## format_ITS_L6_AA$Group11   -14159.2348  4795.6515        40.992368   -198955.00
## format_ITS_L6_AA$Group12   -18166.5582 -6299.4358      -572.562405   -194092.61
## format_ITS_L6_AA$Group13    -7055.2094 -6269.8086       973.632343    -29072.85
## dph                          -959.8622  -395.3803         1.486597    -12447.15
##                            Exophiala Minimelanolocus Phialophora   Veronaea
## (Intercept)               331727.175       21598.401   250795.95  6517.5696
## format_ITS_L6_AA$Group11 -145960.813       -4879.129  -108700.96  1686.0482
## format_ITS_L6_AA$Group12 -149437.873       -9619.757  -114992.12 -3044.0895
## format_ITS_L6_AA$Group13   58717.982       21114.735   -67209.31 -3044.0895
## dph                        -9446.146        -611.959    -7146.88  -182.8147
##                          unidentified.6      X__.20 Bradymyces     Knufia
## (Intercept)                  18865.0551  11021.4702  88567.368  216127.40
## format_ITS_L6_AA$Group11     -7775.9078 -12805.8319 -40895.441 -119207.02
## format_ITS_L6_AA$Group12     -7777.9172 -13318.9290 -39978.055  -13233.46
## format_ITS_L6_AA$Group13     -7681.9983  41022.9837 -11361.865   95349.40
## dph                           -583.5336    204.8589  -2499.908   -4274.33
##                          Trichomerium unidentified.7 unidentified.8      X__.21
## (Intercept)                 85.916445      -967.7322     37405.8604  314413.304
## format_ITS_L6_AA$Group11   -61.321539     -2426.1248    -18411.9377 -133863.408
## format_ITS_L6_AA$Group12   183.964617     -1788.0417    -18294.6464 -144275.987
## format_ITS_L6_AA$Group13   -61.321539      6640.2912    -15327.9331   27794.318
## dph                         -1.294469       178.6240      -999.2678   -8844.813
##                               X__.22 Aspergillus Penicillium Phialosimplex
## (Intercept)               314153.822  24607932.8   5757201.8    3313.40656
## format_ITS_L6_AA$Group11 -251898.447 -11188441.0  -3735863.8   -2240.92403
## format_ITS_L6_AA$Group12 -245757.962 -11144176.3  -2870052.5   -2240.92403
## format_ITS_L6_AA$Group13  733465.137  26735293.6   8595858.3    6722.77209
## dph                        -3193.913   -616929.9   -103901.6     -56.44645
##                           Xeromyces Sagenomella Talaromyces Thermomyces
## (Intercept)              206550.963   253.15177   8068965.6   61362.130
## format_ITS_L6_AA$Group11 -96271.107  -147.15173  -3762211.1  -20014.365
## format_ITS_L6_AA$Group12 -79804.556   215.97119  -3047170.0  -36351.784
## format_ITS_L6_AA$Group13 221567.009  -147.15173   6911706.2   76373.378
## dph                       -5804.203    -5.57895   -221680.3   -1288.381
##                          Xerochrysium unidentified.9 Mycocalicium     X__.23
## (Intercept)                 19786.609     14101.8740    55769.727  53657.921
## format_ITS_L6_AA$Group11   -33450.095     -3606.2246   -25649.430 -22087.651
## format_ITS_L6_AA$Group12   -28962.473     -7259.9912   -25745.683 -24765.917
## format_ITS_L6_AA$Group13    95726.433     16456.5540   -25745.683 -23743.742
## dph                           728.467      -355.5864    -1580.213  -1520.632
##                               X__.24 unidentified.10 Arachnomyces
## (Intercept)               348757.870      111959.959   39631.2506
## format_ITS_L6_AA$Group11 -134410.998      -57148.284  -21312.3670
## format_ITS_L6_AA$Group12 -166975.106      -69095.604  -30613.7621
## format_ITS_L6_AA$Group13 -138854.170       28071.029   22771.9065
## dph                        -9536.305       -2255.969    -474.6047
##                          unidentified.11 Ctenomyces Gymnoascoideus Gymnoascus
## (Intercept)                    4800.1665  802584.84      95.390862  998234.64
## format_ITS_L6_AA$Group11      -2015.8812 -380761.73     113.510390 -434719.76
## format_ITS_L6_AA$Group12      -2015.8812 -414707.12     -55.476145 -451878.04
## format_ITS_L6_AA$Group13      -2015.8812 -140489.84     -55.476145 -129109.80
## dph                            -146.5413  -20353.35      -2.100775  -26308.25
##                          Kraurogymnocarpa Testudomyces unidentified.12
## (Intercept)                    187.670620   2075.07676       7814.0453
## format_ITS_L6_AA$Group11      -129.875399   -999.24940      -3783.7430
## format_ITS_L6_AA$Group12      -129.875399   -999.24940      -3803.4999
## format_ITS_L6_AA$Group13       -40.993778   -999.24940      -3069.0198
## dph                             -3.041854    -56.62249       -211.0813
##                              X__.25 Amauroascus Aphanoascus Auxarthron
## (Intercept)              -39.622690  110445.973   759218.42  654506.15
## format_ITS_L6_AA$Group11 -82.582417  -55270.065  -379746.38 -289095.90
## format_ITS_L6_AA$Group12  -4.227572  -56205.661  -263188.41 -294807.64
## format_ITS_L6_AA$Group13  65.553618  -31806.835   296663.45 -262864.51
## dph                        6.431848   -2838.402   -16992.22  -18886.33
##                            Mallochia Chrysosporium Malbranchea Spiromastix
## (Intercept)               409.801557    2556148.70  3526.18056  29591.6613
## format_ITS_L6_AA$Group11 -307.666046   -1155225.72 -2068.07851 -13982.0819
## format_ITS_L6_AA$Group12 -307.666046   -1192776.47 -1990.04636 -13973.4434
## format_ITS_L6_AA$Group13 -307.666046      45245.81 -2068.93100 -14032.7652
## dph                        -5.375553     -71567.79   -76.69735   -818.8893
##                          unidentified.13 unidentified.14 Pyxidiophora
## (Intercept)                   1706625.56       8467.3978   109291.997
## format_ITS_L6_AA$Group11      -774266.73      -3547.3592   -51631.485
## format_ITS_L6_AA$Group12      -854038.59      -3547.3592   -28681.649
## format_ITS_L6_AA$Group13        -9625.46      -3547.3592   128219.565
## dph                            -44342.54       -258.9494    -3022.484
##                          Botryolepraria     X__.26   Erysiphe Phyllactinia
## (Intercept)                  129.124935 -4466.6252  7655.6175    2.0141350
## format_ITS_L6_AA$Group11     109.550290 -1853.7556 -9752.8499  -13.4811685
## format_ITS_L6_AA$Group12     -30.168708 -9011.0410 -9502.8868  -12.6067728
## format_ITS_L6_AA$Group13     -47.421461 19907.5593 29008.5866  -13.4811685
## dph                           -4.300183   721.7184   110.3807    0.6035281
##                          Podosphaera      X__.27     X__.28 Articulospora
## (Intercept)               -4471.5119  226212.704  77310.344     18325.414
## format_ITS_L6_AA$Group11  -3722.2154 -121932.666 -34124.534     -8157.956
## format_ITS_L6_AA$Group12  -3720.6789   16252.432 -36629.172     -8300.520
## format_ITS_L6_AA$Group13  11165.1097  196606.599 -36657.535     -7333.080
## dph                         431.2488   -5037.088  -2139.488      -527.626
##                          Scytalidium Tetracladium      X__.29 Amphobotrys
## (Intercept)               3115.81485   30033064.9  315326.610  103.785850
## format_ITS_L6_AA$Group11 -1044.29626  -13867508.6 -149114.061  103.058666
## format_ITS_L6_AA$Group12 -1503.73361  -14060486.2 -152670.945  -38.115617
## format_ITS_L6_AA$Group13 -1504.93728   -5002748.8  -67123.900  -38.115617
## dph                        -84.78303    -805708.5   -8539.331   -3.456328
##                           Cadophora Leohumicola   Cistella Setoscypha
## (Intercept)              1951001.02   7635473.2  902578.90 230.230653
## format_ITS_L6_AA$Group11 -954056.80  -3547130.3 -408773.96 -84.552793
## format_ITS_L6_AA$Group12 -942312.21  -3526834.5 -430999.69 242.010741
## format_ITS_L6_AA$Group13 -627287.29  -1970975.3 -236645.15 -72.905155
## dph                       -52448.75   -207923.4  -24782.11  -7.667256
##                          Myxotrichum Oidiodendron   Botrytis      X__.30
## (Intercept)               190112.085    173133.99   4165.024  28618.1306
## format_ITS_L6_AA$Group11 -119067.295    -75631.52 -22064.989 -22215.9870
## format_ITS_L6_AA$Group12  -76019.488    -78147.76 -22112.429 -20774.0013
## format_ITS_L6_AA$Group13  314622.352     15422.76  57457.355  55617.3346
## dph                        -3345.091     -4897.54   1020.861   -310.8463
##                            Geomyces Pseudeurotium Pseudogymnoascus
## (Intercept)               4128.2690      57569.81       18908214.4
## format_ITS_L6_AA$Group11 -1755.2510     -21694.20       -8909018.7
## format_ITS_L6_AA$Group12 -1755.2510     -26563.59       -8749967.4
## format_ITS_L6_AA$Group13 -1710.8449     -24972.23       -3566794.2
## dph                       -124.8957      -1628.51        -503737.4
##                          unidentified.15 Thelebolus     X__.31     X__.32
## (Intercept)                    185.95935  454462.41  84.030514  429.37029
## format_ITS_L6_AA$Group11      -229.98710 -214051.38 -34.278928 -198.87843
## format_ITS_L6_AA$Group12      -217.08659 -222664.04 -34.522495 -202.43114
## format_ITS_L6_AA$Group13       677.06080 -184438.34 -34.522495 -202.43114
## dph                              2.31725  -12094.06  -2.605685  -11.94417
##                          Arthrobotrys  Dactylaria unidentified.16
## (Intercept)                2359.56085  23997.2283       75387.946
## format_ITS_L6_AA$Group11  -1003.56148 -11006.2953      -31265.600
## format_ITS_L6_AA$Group12  -1003.56148 -11006.2953      -31358.399
## format_ITS_L6_AA$Group13  -1003.56148 -11006.2953       76562.935
## dph                         -71.36839   -683.7333       -2317.345
##                          unidentified.17     X__.33     X__.34  Ascobolus
## (Intercept)                    429.29279  71522.812 101355.594  771490.73
## format_ITS_L6_AA$Group11       276.34102 -33527.673 -52078.067 -330819.58
## format_ITS_L6_AA$Group12      -191.31048 -33474.569 -51061.190 -352195.23
## format_ITS_L6_AA$Group13      -191.31048  32068.143  86167.991  244626.53
## dph                            -12.52539  -1998.968  -2582.383  -20900.14
##                          Cephaliophora Iodophanus Kalaharituber      Peziza
## (Intercept)                  118450.50  6194.6019      4792.263  26033.0702
## format_ITS_L6_AA$Group11     -36266.29 -2802.6234     -2226.712 -10083.1915
## format_ITS_L6_AA$Group12     -19672.07 -2911.9790     -2226.712 -11128.2756
## format_ITS_L6_AA$Group13      51912.83  8556.8043     -2226.712  11080.3555
## dph                           -2867.16  -172.7696      -135.029   -730.6661
##                             Terfezia unidentified.18    Coprotus    X__.35
## (Intercept)               6496.09407      458.721031  22215.8844  76211.48
## format_ITS_L6_AA$Group11 -4766.74685     -367.967095 -10304.0587 -33026.36
## format_ITS_L6_AA$Group12 -4962.38664     -594.241295 -10304.5458 -35602.96
## format_ITS_L6_AA$Group13  6781.86418     -594.241295 -10251.2169  26742.55
## dph                        -80.72144        7.132645   -626.9126  -2116.81
##                          Cheilymenia     Geopora    Heydenia Lasiobolidium
## (Intercept)                72825.434  21673.1959  3047936.34    1456525.98
## format_ITS_L6_AA$Group11  -37029.785  -9206.3485 -1456752.17    -650481.51
## format_ITS_L6_AA$Group12  -43879.558 -11149.3321 -1452471.35    -679236.44
## format_ITS_L6_AA$Group13   33494.226   4016.0738  -373994.65    -576414.59
## dph                        -1440.523   -536.6079   -79334.46     -40798.78
##                          Paurocotylis Pseudaleuria  Pulvinula Scutellinia
## (Intercept)                24547.0675   1741.85715 1164702.29  13389133.6
## format_ITS_L6_AA$Group11  -11398.4596   -520.35634 -502434.81  -6143409.0
## format_ITS_L6_AA$Group12  -11593.1386   -736.33422 -549418.89  -6148869.5
## format_ITS_L6_AA$Group13  -11593.1386   -736.33422 -277719.01  -3430856.9
## dph                         -681.7857    -52.92226  -32354.43   -368015.8
##                          unidentified.19 Pneumocystis     X__.36 Debaryomyces
## (Intercept)                    26542.096    9387.2027 1682781.53    150291.77
## format_ITS_L6_AA$Group11      -12203.687   -5547.1196 -956303.86    -66389.59
## format_ITS_L6_AA$Group12      -11978.189    7247.5340 -800227.13    -31763.30
## format_ITS_L6_AA$Group13        -801.971    -743.5020 2230926.76    163037.24
## dph                             -746.835    -192.4592  -37399.79     -4403.55
##                          Hyphopichia Meyerozyma Millerozyma unidentified.20
## (Intercept)               245494.543  26223.407   7.0219784      -2404.0352
## format_ITS_L6_AA$Group11 -110978.326 -49328.281  -2.5788394      -4542.7815
## format_ITS_L6_AA$Group12 -109243.050 -43841.148  -2.3772873      -4530.0108
## format_ITS_L6_AA$Group13  310947.896 138971.997   7.5349661      13615.5738
## dph                        -7007.311   1254.095  -0.2338494        365.6219
##                           Clavispora   Kodamaea Cyberlindnera   Starmera
## (Intercept)               103024.911  7283.8703     398.97998  4858.8222
## format_ITS_L6_AA$Group11 -136583.515 -4351.1540    -146.52641 -1784.7100
## format_ITS_L6_AA$Group12 -120476.015 -3221.6915    -146.52641  5096.1684
## format_ITS_L6_AA$Group13  380294.657  8626.4922     432.17724 -1750.5432
## dph                         2525.191  -154.3535     -13.28703  -161.7954
##                          Wickerhamomyces Eremothecium Issatchenkia Kazachstania
## (Intercept)                    464.12065   15.6089450    76.804244    1007.2675
## format_ITS_L6_AA$Group11      -780.44042  -10.7821419  -107.402107   -4171.0221
## format_ITS_L6_AA$Group12      -513.10605   32.3464256  -107.402107    6824.9707
## format_ITS_L6_AA$Group13      2034.63404  -10.7821419   322.206321    1517.0734
## dph                             16.72605   -0.2540423     1.610414     166.5134
##                          Saccharomyces Zygosaccharomyces      Candida
## (Intercept)                 11635.0188          520.7687  48767925.17
## format_ITS_L6_AA$Group11   -20989.0671          487.7451 -45470154.46
## format_ITS_L6_AA$Group12   -20743.7715         -115.2185 -22566369.08
## format_ITS_L6_AA$Group13    61578.3938         -191.2536 102739941.18
## dph                           497.8517          -17.3429    -84877.06
##                              Diutina Sympodiomyces Blastobotrys Trichomonascus
## (Intercept)               2367414.02    123.798088    617.41983      6381.0483
## format_ITS_L6_AA$Group11 -1026204.26    -89.557975   -417.57355     -3766.5899
## format_ITS_L6_AA$Group12  2633432.47     61.920236    465.57834     -3155.7930
## format_ITS_L6_AA$Group13  -599811.79     58.009611    369.56876     10688.9729
## dph                        -66543.69     -1.802111    -10.51823      -137.6031
##                          Zygoascus   X__.37 unidentified.21 Coniochaeta
## (Intercept)              14747.157  8371034       0.8861028  31056.9500
## format_ITS_L6_AA$Group11 -2971.447 -3954294      -9.4351692 -13934.5430
## format_ITS_L6_AA$Group12 11807.754 -4022855      -8.1783912 -13691.4804
## format_ITS_L6_AA$Group13 -5267.331  -326179      -9.4351692   7086.6170
## dph                       -488.170  -220505       0.4499509   -894.5451
##                          unidentified.22   Diaporthe Cryptosphaeria  Cytospora
## (Intercept)                   3496.22610  56409.5749     2369.04950 1565.09724
## format_ITS_L6_AA$Group11      -624.04167 -60239.1155    -1048.10717 -642.54768
## format_ITS_L6_AA$Group12     -2213.89921 -39331.7583    -1048.10717 -642.54768
## format_ITS_L6_AA$Group13      4811.88168 160325.9710    -1048.10717 -642.54768
## dph                            -67.49089    247.9718      -69.52328  -48.55524
##                          unidentified.23 Colletotrichum     X__.38
## (Intercept)                    4392.1957     439089.085 16992.8104
## format_ITS_L6_AA$Group11      -1904.2170    -222056.387 -6991.9263
## format_ITS_L6_AA$Group12      -1904.2170    -153877.203 -7008.8109
## format_ITS_L6_AA$Group13      -1904.2170     235570.068 13495.2218
## dph                            -130.9462      -9960.169  -525.4737
##                          Acrostalagmus Gibellulopsis   Lectera Plectosphaerella
## (Intercept)                  293534.09    23330975.6  779490.4         56462444
## format_ITS_L6_AA$Group11    -130258.00   -11086237.7 -348604.2        -26530725
## format_ITS_L6_AA$Group12    -163218.72   -11346244.3 -380971.4        -27259994
## format_ITS_L6_AA$Group13     -54455.28     -398338.7 -292895.2         -6552075
## dph                           -6849.90     -619339.9  -20963.0         -1511479
##                          Sodiomyces Verticillium unidentified.24      X__.39
## (Intercept)               56937.524    1710235.0      19058.4339  2629567.44
## format_ITS_L6_AA$Group11 -24377.303    -733413.8      -9817.7170 -1276682.13
## format_ITS_L6_AA$Group12 -26452.823    -816917.8      -9817.7170 -1251577.71
## format_ITS_L6_AA$Group13 -18271.747    -417095.8      -9747.5066  -253027.56
## dph                       -1602.149     -46510.1       -486.3535   -70788.21
##                              X__.40 Clonostachys  Geosmithia  Gliomastix
## (Intercept)              135006.853    563458.61  225612.329  34272.6886
## format_ITS_L6_AA$Group11 -61718.356   -282060.60  -95519.995 -15600.8393
## format_ITS_L6_AA$Group12 -61745.690   -146571.86 -105219.307 -15735.0400
## format_ITS_L6_AA$Group13 -21005.036    402643.36  -43967.770 -15533.5750
## dph                       -3855.851    -14336.54   -6278.472   -975.6657
##                          Hydropisphaera Nectriopsis    Selinia Verrucostoma
## (Intercept)                  22146.7287  2372364.94  4229.8639    7038.3484
## format_ITS_L6_AA$Group11    -10324.1980 -1193321.60 -1547.6071   -3399.4944
## format_ITS_L6_AA$Group12    -10325.9029 -1150032.31 -2151.4886   -3399.4944
## format_ITS_L6_AA$Group13    -10325.9029  -171691.42  3546.7075   -3399.4944
## dph                           -622.1487   -58545.67  -102.6098    -191.5186
##                          unidentified.25     X__.41 Aschersonia Metacordyceps
## (Intercept)                  7045.115754  6641.9984  -2339.5914     82687.039
## format_ITS_L6_AA$Group11    -1756.686264 -4731.1071 -15210.0868    -57077.533
## format_ITS_L6_AA$Group12    -3478.086042 -4731.1071 -15310.0376    -58862.851
## format_ITS_L6_AA$Group13        6.273257 13490.1308  44818.7635     35279.682
## dph                          -187.738406  -100.5732    939.1208     -1241.424
##                          Metarhizium Paecilomyces     X__.42  Beauveria
## (Intercept)                695353.96    90.754189 103.815285 1557846.94
## format_ITS_L6_AA$Group11  -300601.83   -33.329707  86.496556 -674981.92
## format_ITS_L6_AA$Group12  -308561.93    11.791584 -38.126428 -737269.09
## format_ITS_L6_AA$Group13    68936.27    49.880026 -38.126428  -46971.48
## dph                        -15904.34    -3.022341  -3.457308  -41902.21
##                          Engyodontium Lecanicillium Simplicillium Monocillium
## (Intercept)                 9033.9373    4653.74849    3241.22778  106013.811
## format_ITS_L6_AA$Group11   -3743.4907   -1995.69188    -262.78135  -62393.884
## format_ITS_L6_AA$Group12   -3629.2317   -2130.40118   -1535.16999   14121.099
## format_ITS_L6_AA$Group13   -3743.8173   10305.09496   -1535.16999   13922.304
## dph                         -278.4274      90.71681     -89.79252   -2216.092
##                          Trichoderma     X__.43 Acremonium Emericellopsis
## (Intercept)               2181228.78  353525.20  6247108.6      61254.512
## format_ITS_L6_AA$Group11 -1126128.11 -179822.50 -2949510.6     -32396.553
## format_ITS_L6_AA$Group12  -942853.08 -190013.90 -2976670.6     -35867.700
## format_ITS_L6_AA$Group13  2200803.89  -78064.04  -448591.9      75884.917
## dph                        -55251.28   -8580.70  -169056.0      -1330.525
##                          Fusariella Olpitrichum Sarocladium Stanjemonium
## (Intercept)               2960726.9   97937.263   7966445.9    6553.1241
## format_ITS_L6_AA$Group11 -1423811.7  -34767.241  -4076694.2   -2824.7200
## format_ITS_L6_AA$Group12 -1277851.8  -51669.488  -3791809.0   -2825.2071
## format_ITS_L6_AA$Group13   465505.5   -4787.038   5518882.1   -2825.2071
## dph                        -76423.8   -2435.146   -204141.9    -196.2062
##                          Trichothecium Ustilaginoidea unidentified.26
## (Intercept)                 2812.08349     2460.44453       46608.920
## format_ITS_L6_AA$Group11   -1356.44370     -963.77584      -19021.175
## format_ITS_L6_AA$Group12   -1292.90258     -939.39645      -19172.982
## format_ITS_L6_AA$Group13    -291.75673     2952.48647       55809.778
## dph                          -76.57737      -73.55419       -1443.997
##                              X__.44 Bisifusarium Cosmospora Cylindrocarpon
## (Intercept)              20311390.4   1602.87118 20982.6381     130519.297
## format_ITS_L6_AA$Group11 -9415449.2  -1409.37071 -8621.9852     -84461.666
## format_ITS_L6_AA$Group12 -9700770.6  -1797.12317 -9139.7366     -88019.470
## format_ITS_L6_AA$Group13 -3007959.1   5022.26562 24410.6535      -8584.002
## dph                       -539885.4     11.20529  -623.3106      -2225.504
##                          Dactylonectria  Fusarium  Fusicolla Gibberella
## (Intercept)                  1546749.84 156622009  4003818.3  5467367.7
## format_ITS_L6_AA$Group11     -727261.01 -79297164 -1968104.7 -2686464.8
## format_ITS_L6_AA$Group12     -639977.22 -72632596 -1772966.5 -2689978.0
## format_ITS_L6_AA$Group13       71972.54  48550849   288026.8   626547.5
## dph                           -40542.89  -3959370  -102693.2  -140451.9
##                          Ilyonectria    Nectria Neocosmospora  Neonectria
## (Intercept)                3693.0451  757900.65    2197.56943  2721.83566
## format_ITS_L6_AA$Group11   2662.8656 -333207.65    -874.05081 -1117.44442
## format_ITS_L6_AA$Group12  -1627.5675 -364560.62    -991.81338 -1117.44442
## format_ITS_L6_AA$Group13  -1631.9798  133468.37    -991.81338 -1117.44442
## dph                        -108.4771  -20593.41     -63.46084   -84.44164
##                           Volutella Eucasphaeria    X__.45 Drechmeria
## (Intercept)               86201.302    493838.05 199.74984  7091.5432
## format_ITS_L6_AA$Group11 -41730.247   -247560.99 -97.25661 -2921.5504
## format_ITS_L6_AA$Group12 -41370.723   -261488.85 -97.25661 -2921.5504
## format_ITS_L6_AA$Group13 -34974.151    -68448.42 -97.25661 -2921.5504
## dph                       -2338.104    -12121.27  -5.39438  -219.4733
##                          Harposporium Ophiocordyceps Purpureocillium     X__.46
## (Intercept)                21161.7107     20892.9690       44027.716 1908589.47
## format_ITS_L6_AA$Group11  -23982.5318     -9039.2400      -24633.735 -855896.94
## format_ITS_L6_AA$Group12  -23951.6844     -9359.3032      -24937.115 -943079.77
## format_ITS_L6_AA$Group13   39915.7871     27866.9685        5373.328 -466780.76
## dph                          148.9797      -601.2918        -997.078  -50549.72
##                          Achroiostachys    Alfaria Myrothecium Paramyrothecium
## (Intercept)                  232011.815  4650.5627   78818.158      2027609.10
## format_ITS_L6_AA$Group11    -106102.874 -2508.3414  -34610.593      -918791.99
## format_ITS_L6_AA$Group12    -106526.579 -2453.7679  -37926.422      -954459.98
## format_ITS_L6_AA$Group13     -31999.378 -2521.0767   95426.276      -352951.56
## dph                           -6604.028  -112.0782   -2113.016       -56398.49
##                          Stachybotrys Striatibotrys unidentified.27
## (Intercept)                 3837277.4    20794.2367       5614.9674
## format_ITS_L6_AA$Group11   -1775783.2    -9953.2031      -2613.2967
## format_ITS_L6_AA$Group12   -1868792.8   -10994.9531      -2613.2967
## format_ITS_L6_AA$Group13   -1315102.4    -9701.9378      -2613.2967
## dph                         -103096.7     -515.7518       -157.9827
##                          Tilachlidium unidentified.28      X__.47 Falciphora
## (Intercept)                 79152.125      1931026.51  6851.72507  902.38992
## format_ITS_L6_AA$Group11   -36458.203      -910571.78 -7696.67109 1976.33193
## format_ITS_L6_AA$Group12   -36693.646      -942505.90 -7588.91809 -658.77731
## format_ITS_L6_AA$Group13   -28948.679        85170.12 22324.26243 -658.77731
## dph                         -2231.331       -51802.23    46.44877  -12.82172
##                          Gaeumannomyces Harpophora Magnaporthe Magnaporthiopsis
## (Intercept)                  2406.41475  67.844013   -681.2924        821393.45
## format_ITS_L6_AA$Group11     1201.57984  56.991835  -8868.5100       -380903.33
## format_ITS_L6_AA$Group12    -1058.53054 -24.915886  -8830.3085       -399106.22
## format_ITS_L6_AA$Group13    -1058.53054 -24.915886  18830.1917       -231015.40
## dph                           -70.94127  -2.259375    502.6212        -22225.64
##                          Ophioceras Pyricularia Slopeiomyces unidentified.29
## (Intercept)               22278.975   -6414.604    58962.521        12.54529
## format_ITS_L6_AA$Group11 -10368.995  -17773.355   -27328.496       -90.55415
## format_ITS_L6_AA$Group12 -10368.995  -17467.013   -27328.496       -90.55415
## format_ITS_L6_AA$Group13 -10368.995   52929.744   -27328.496       -90.55415
## dph                        -626.841    1273.050    -1664.949         4.10573
##                          Melanospora Aniptodera unidentified.30     X__.48
## (Intercept)                576567.43  463.13426       474.01047 156518.733
## format_ITS_L6_AA$Group11  -255939.36 -191.64783      -200.34726 -71025.727
## format_ITS_L6_AA$Group12  -266784.69 -192.07408      -200.34726 -75082.987
## format_ITS_L6_AA$Group13   -83111.20 -192.07408      -200.34726 -60048.255
## dph                        -16304.35  -14.26633       -14.40333  -4283.697
##                             Acaulium Cephalotrichum      Kernia Microascus
## (Intercept)               220533.546      403752.77  81108.3464  4258331.2
## format_ITS_L6_AA$Group11 -104618.609     -187125.30 -58929.1914 -1920936.5
## format_ITS_L6_AA$Group12 -123950.224     -190682.35 -52643.7902 -1871066.5
## format_ITS_L6_AA$Group13   72877.901       56430.63 107597.9080  5389360.3
## dph                        -4995.291      -11168.90   -975.0332  -120621.6
##                           Petriella Pithoascus Scedosporium Scopulariopsis
## (Intercept)               3.1973224  889139.30   227009.519     135425.055
## format_ITS_L6_AA$Group11 -1.1742248 -483789.34  -103666.420     -65107.161
## format_ITS_L6_AA$Group12 -0.3605841 -433516.85  -103291.524     -65044.099
## format_ITS_L6_AA$Group13  2.7090337  661085.97   -20693.170      43742.246
## dph                      -0.1064788  -20164.19    -6190.913      -3700.942
##                          unidentified.31 Cephalotrichiella Wardomyces
## (Intercept)                   288274.856        2386.48484  63961.790
## format_ITS_L6_AA$Group11     -129449.356         250.27186 -24151.532
## format_ITS_L6_AA$Group12     -134234.593       -1470.46150 -30620.859
## format_ITS_L6_AA$Group13        9498.640       -1387.50532 -16437.492
## dph                            -8106.505         -48.21175  -1754.786
##                          Myrmecridium Phyllachora     X__.49 Phialemonium
## (Intercept)                 548173.86  54.9435809  901688.92   27.0408529
## format_ITS_L6_AA$Group11   -248827.69 -42.7646968 -443806.89  -33.4430486
## format_ITS_L6_AA$Group12   -257538.95 -42.7646968 -429455.81   41.8099263
## format_ITS_L6_AA$Group13    -30187.21 103.5551777  129126.20   25.0761710
## dph                         -15296.57  -0.6409939  -23181.43    0.3369577
##                              X__.50 Achaetomium Acrophialophora     Amesia
## (Intercept)              1421433.80   63151.740       5532.8775  71.674089
## format_ITS_L6_AA$Group11 -667418.99  -29680.786      -2581.4402 -50.390582
## format_ITS_L6_AA$Group12 -710677.98  -29714.915      -2341.0029  27.314340
## format_ITS_L6_AA$Group13 -183426.07  -29714.915      -2230.2917 -50.390582
## dph                       -37172.33   -1759.833       -155.3388  -1.120185
##                          Botryotrichum Chaetomium Dichotomopilus   Humicola
## (Intercept)                 22543047.4  4978561.5      67586.574  4030428.4
## format_ITS_L6_AA$Group11   -10704398.4 -2051816.3     -29438.435 -1962375.4
## format_ITS_L6_AA$Group12   -10656386.5 -2353692.8     -32065.247 -2039047.2
## format_ITS_L6_AA$Group13    -1512690.3  -431224.1     -30312.341   333339.1
## dph                          -597854.9  -137878.3      -1866.425  -101448.3
##                          Melanocarpus Mycothermus Subramaniula  Thielavia
## (Intercept)                 51976.992   72.765294   1432.78463  5864.1273
## format_ITS_L6_AA$Group11   -23188.155   56.929008   -629.73265 -2524.3272
## format_ITS_L6_AA$Group12   -23430.645  -40.698981   -629.73265 -2556.1693
## format_ITS_L6_AA$Group13   -23489.888  -40.698981   -493.44750 -2556.1693
## dph                         -1480.921   -1.687701    -42.26589  -174.1031
##                           Zopfiella unidentified.32 Endophragmiella    X__.51
## (Intercept)               584341.65       460225.36      14433.5371  89159.92
## format_ITS_L6_AA$Group11 -241267.62      -231561.01      -5967.4212 -39451.49
## format_ITS_L6_AA$Group12 -267286.76      -212460.34      -5969.1262 -45600.29
## format_ITS_L6_AA$Group13  134830.95       -50000.13      17486.0941 -15049.64
## dph                       -16175.48       -11533.83       -445.4953  -2277.75
##                           Cercophora Cladorrhinum  Podospora Schizothecium
## (Intercept)               276291.047    47955.339  4962788.3     9102217.5
## format_ITS_L6_AA$Group11 -118555.870   -24853.449 -2397967.4    -4210832.0
## format_ITS_L6_AA$Group12 -140372.365   -25487.791 -2524713.1    -4403117.7
## format_ITS_L6_AA$Group13   41196.002   -21610.750  -705691.6    -2497593.8
## dph                        -7142.361    -1181.159  -124456.4     -247040.4
##                          unidentified.33  Neurospora   Sordaria Ramophialophora
## (Intercept)                    9252.2099  457.107650 166478.529       6077.0188
## format_ITS_L6_AA$Group11     -15884.3002 -295.144354 -78151.983      -4485.4650
## format_ITS_L6_AA$Group12     -15934.9733 -274.575304 -77484.987      -4853.4016
## format_ITS_L6_AA$Group13      30092.2372  610.105657 -72839.360       9004.7781
## dph                             351.7244   -8.524384  -4644.812        -64.4009
##                          Remersonia Staphylotrichum unidentified.34
## (Intercept)              110066.803       4764.5986       6460.4068
## format_ITS_L6_AA$Group11 -49717.557      -1816.3261       2082.3822
## format_ITS_L6_AA$Group12 -51553.496      -2121.9508      -2635.7085
## format_ITS_L6_AA$Group13 -50259.210      -2121.9508       2998.0583
## dph                       -3073.422       -139.0867       -197.0117
##                          Pleurophragmium Xylomelasma Phaeoacremonium
## (Intercept)                    62933.151  1774.51743      2.60156927
## format_ITS_L6_AA$Group11      -29292.389  -770.14864     -3.41912687
## format_ITS_L6_AA$Group12      -29292.389  -770.14864     -2.44594302
## format_ITS_L6_AA$Group13      -29292.389  -770.14864     -3.41912687
## dph                            -1770.566   -52.86152      0.04302935
##                           Nigrospora      X__.52  Arthrinium Coniocessia
## (Intercept)               42203.8548  328.146294  3789.57305  25955.5856
## format_ITS_L6_AA$Group11 -33891.3320 -155.569746 -1224.55396 -13359.9675
## format_ITS_L6_AA$Group12 -37088.7816 -155.569746  1246.71366 -13447.6542
## format_ITS_L6_AA$Group13  91196.7481 -155.569746 -1985.94235 -10127.4134
## dph                        -241.4186   -9.082976   -94.92793   -658.3122
##                             X__.53   Diatrype  Eutypella Monosporascus
## (Intercept)               6.332107 -2086.1530 191.621398     83941.688
## format_ITS_L6_AA$Group11 -2.325482 -3925.1314 122.176550    -37957.617
## format_ITS_L6_AA$Group12 -2.325482 -3911.2399 -27.946290    -40484.852
## format_ITS_L6_AA$Group13 -2.325482 11761.5027 -32.872499    -28820.676
## dph                      -0.210875   316.3834  -6.381471     -2280.287
##                          Monographella   Idriella Microdochium unidentified.35
## (Intercept)                 -33.186313 1828.92150   302944.374      2983.70895
## format_ITS_L6_AA$Group11    -62.404091 -814.88945  -140890.625     -1358.65630
## format_ITS_L6_AA$Group12    -63.073901 -814.88945  -142951.432      -944.05550
## format_ITS_L6_AA$Group13    162.092872 -714.15695   -88425.830      2746.65925
## dph                           5.066327  -53.37011    -8347.219       -85.52909
##                               X__.54  Ascotricha Coniolariella  Hypoxylon
## (Intercept)               4014.69301  154.378387     8940.7636  3.9942760
## format_ITS_L6_AA$Group11  4330.47734 -128.645135    -3875.5027 -1.4669080
## format_ITS_L6_AA$Group12 -3197.41450 -128.645135    -3448.0076  0.7255005
## format_ITS_L6_AA$Group13 -2656.18825 -128.645135    10665.4293 -1.4669080
## dph                        -43.01466   -1.354382     -266.5927 -0.1330194
##                              Poronia  Rosellinia    Xylaria Zygosporium
## (Intercept)               287.115163  3056.35430  496077.14  514.923509
## format_ITS_L6_AA$Group11 -117.874581 -2193.45277 -219327.01 -351.285544
## format_ITS_L6_AA$Group12 -117.874581 -1883.74808 -230696.32 -351.285544
## format_ITS_L6_AA$Group13 -117.874581 -2193.45277  -51472.72 1053.856631
## dph                        -8.907399   -45.41587  -13702.81   -8.612524
##                            Fusidium Hansfordia Neoidriella Phialemoniopsis
## (Intercept)              159912.568  6659.4004   2330.3891       81913.501
## format_ITS_L6_AA$Group11 -74127.562 -3731.0014   -567.5306      -35498.251
## format_ITS_L6_AA$Group12 -74533.267 -3729.8929   -992.8414      -38776.227
## format_ITS_L6_AA$Group13 -44481.268 -2738.6057   -969.6860      102906.621
## dph                       -4474.914  -154.1263    -67.5617       -2247.045
##                          unidentified.36 unidentified.37 Symbiotaphrina
## (Intercept)                   1074.33876      13726.9878     -146.09617
## format_ITS_L6_AA$Group11      -445.24612      -5966.0320     -361.85480
## format_ITS_L6_AA$Group12      -445.24612      -5630.5421     -361.85480
## format_ITS_L6_AA$Group13      -445.24612       9489.2736      845.90048
## dph                            -33.11014       -408.4714       26.73426
##                          Basidiobolus     X__.55    X__.56     X__.57
## (Intercept)                 859.06351 1033251.42  72056.97 170222.685
## format_ITS_L6_AA$Group11   -423.06605 -501268.56 -36589.37 -72125.145
## format_ITS_L6_AA$Group12   -423.06605 -155094.79 -35903.15 -82335.411
## format_ITS_L6_AA$Group13   -191.97384  563029.25 -11780.34 -76500.996
## dph                         -22.94723  -22740.62  -1861.26  -4581.875
##                              X__.58   Agaricus   Coprinus Melanophyllum
## (Intercept)              13446.3687   74.75360  329.63046     745.53618
## format_ITS_L6_AA$Group11 -4464.8867 -287.62267  309.39726    -315.00599
## format_ITS_L6_AA$Group12 -6403.4372 -272.89891 -121.05763    -315.00599
## format_ITS_L6_AA$Group13 -6329.6206  407.72273 -121.05763    -315.00599
## dph                       -370.6806   12.92944  -10.97752     -22.65948
##                           Tulostoma     Amanita   Conocybe  Panaeolus
## (Intercept)               8667.7428    8.709704 16286.5113 16.2926654
## format_ITS_L6_AA$Group11 -5635.8735 -178.422899 -6912.4312 -5.9835228
## format_ITS_L6_AA$Group12 -5634.8709 -162.407667 -6984.0099 -5.9835228
## format_ITS_L6_AA$Group13  2718.4597  509.606775 -6984.0099 -5.9835228
## dph                       -159.5721    8.932273  -489.6053 -0.5425865
##                          Cortinarius Gymnopilus  Crepidotus   Simocybe
## (Intercept)               22143.6804 14.9597914  4930.43338   4.822035
## format_ITS_L6_AA$Group11 -10305.7794 -5.4940215  4600.45029 -34.806327
## format_ITS_L6_AA$Group12 -10109.9672  3.4578086 -3472.02710 -34.806327
## format_ITS_L6_AA$Group13  30721.5261 -4.0377995 -2816.05970 -34.806327
## dph                        -623.0474 -0.4981984   -76.35391   1.578121
##                            Entoloma     X__.59    Naucoria     X__.60
## (Intercept)               48479.733   39.88602  157.596193 -18.809599
## format_ITS_L6_AA$Group11 -20201.267 -282.88572 -106.585501 -35.390573
## format_ITS_L6_AA$Group12 -21901.566 -269.63169  125.822890 -35.390573
## format_ITS_L6_AA$Group13  11792.284  835.40312   87.348111 100.894579
## dph                       -1365.174   12.78946   -2.684773   2.852641
##                             Bovista     Calvatia Lycoperdon   Calocybe
## (Intercept)               8085.5634  13398.01298  63215.729  36514.012
## format_ITS_L6_AA$Group11 -4280.0983 -11687.68892 -31923.709 -15764.399
## format_ITS_L6_AA$Group12 -4280.0983 -11906.35871 -31849.056 -15764.889
## format_ITS_L6_AA$Group13 -2120.5094  -9339.38149 -15291.775  37530.594
## dph                       -200.2876    -77.20171  -1646.617  -1092.059
##                           Lyophyllum Mycenastrum   Gymnopus  Mycetinis
## (Intercept)               138.038770  2881.77076 191.462994  182.30880
## format_ITS_L6_AA$Group11 -118.309116 -1150.46177 -71.735667 -744.50200
## format_ITS_L6_AA$Group12  289.667758 -1191.81336 157.266220 -744.50200
## format_ITS_L6_AA$Group13 -114.235501 -1191.81336 -42.679996 -744.50200
## dph                        -1.038403   -88.94513  -6.301438   29.58912
##                          Rhodocollybia Cylindrobasidium  Flammulina Strobilurus
## (Intercept)                 1334.55585       24.6072474  61.0299613   150.40347
## format_ITS_L6_AA$Group11    -501.56751       -9.0370742  18.3278364  -354.98064
## format_ITS_L6_AA$Group12     655.91978       -1.8254835 -58.2410974  -284.72437
## format_ITS_L6_AA$Group13    -208.10226       -9.0370742 -58.2410974   651.68109
## dph                          -43.84149       -0.8194828  -0.1467823    10.76722
##                             Pleurotus Volvariella      X__.61 Coprinellus
## (Intercept)               112.8169144   44993.787  3277.62265    39983551
## format_ITS_L6_AA$Group11 -106.8689229  -20935.003  3896.42951   -18195381
## format_ITS_L6_AA$Group12   10.4078808  -21032.922 -1562.84950   -18686227
## format_ITS_L6_AA$Group13  -70.1736976  -21032.922 -1562.84950   -12758747
## dph                        -0.3130522   -1261.098   -90.25122    -1118401
##                          Coprinopsis   Parasola Psathyrella Aphanobasidium
## (Intercept)               168204.014 172863.498  161854.472      712.54186
## format_ITS_L6_AA$Group11  -69967.116 -75669.117  -74305.809     -478.64603
## format_ITS_L6_AA$Group12  -56281.455 -85431.527  -74411.355     -382.51452
## format_ITS_L6_AA$Group13   47522.220 -39179.393  147263.580     1339.80658
## dph                        -4760.763  -4585.766   -4393.639      -12.31031
##                          Radulomyces Schizophyllum     X__.62 unidentified.38
## (Intercept)               21.1345264     37987.085  54.798575        510.4739
## format_ITS_L6_AA$Group11   6.4444227    -16629.278 -23.343580       -242.4863
## format_ITS_L6_AA$Group12  13.0266679    -16117.301 -20.565286       -248.8230
## format_ITS_L6_AA$Group13 -10.2034881     44995.814 -23.343580       -213.2703
## dph                       -0.5753178     -1124.095  -1.655526        -13.7711
##                          Hypholoma Kuehneromyces    Pholiota    Tubaria
## (Intercept)               7605.872      29.84798  83.8205688 1191.90019
## format_ITS_L6_AA$Group11 -4572.974    -210.47681 -96.9519316 -489.26179
## format_ITS_L6_AA$Group12 -3617.096     -94.09242   5.6391940 -489.26179
## format_ITS_L6_AA$Group13 12856.603     501.81483 188.2646693 1465.39134
## dph                       -150.952       9.50678   0.6911244  -36.98097
##                           Baeospora  Clitocybe    Collybia Hemimycena
## (Intercept)              1018.94464 19380.4278  2762.07530  39.940139
## format_ITS_L6_AA$Group11 -165.93301 -9927.7757 -1867.02503 -13.110819
## format_ITS_L6_AA$Group12  591.56258 -8490.3667 -1658.53700  -2.106859
## format_ITS_L6_AA$Group13  -53.96567 -1635.9787  5392.58705 -14.668118
## dph                       -30.75016  -495.0415   -47.10791  -1.330106
##                             Lepista  Leucocybe Megacollybia Melanoleuca
## (Intercept)               310.53508  65.032001   -1056.6727   7962.5566
## format_ITS_L6_AA$Group11 -114.04480 -23.883168    -895.8814  -3650.1203
## format_ITS_L6_AA$Group12  192.84816  71.500148    -836.9612  -3650.1203
## format_ITS_L6_AA$Group13  -36.67412 -23.733812    2628.7241  -3650.1203
## dph                       -10.34159  -2.165728     102.7660   -226.9703
##                              Mycena    Panellus Paralepista Pseudoclitocybe
## (Intercept)               2621.2972   81.122149   55.915088      115.041443
## format_ITS_L6_AA$Group11 -7730.6920 -161.643637  -20.534958      -42.249263
## format_ITS_L6_AA$Group12 -6572.2776  -36.417072   36.042323      -39.271775
## format_ITS_L6_AA$Group13 21798.0161  359.704345  -20.534958      -42.249263
## dph                        284.2052    4.237973   -1.862112       -3.831167
##                           Tricholoma     Typhula unidentified.39 Amyloxenasma
## (Intercept)               295.464571  43843.6622      20272.1600    67.526352
## format_ITS_L6_AA$Group11 -108.510115 -25254.5520      -9421.0280   -34.660363
## format_ITS_L6_AA$Group12  231.607774 -24880.4223      -9421.0280    72.742053
## format_ITS_L6_AA$Group13  -79.649449   4492.3883      -9421.0280   -34.660363
## dph                        -9.839708   -937.0836       -571.1122    -1.729789
##                           Amphinema     Athelia Auricularia  Oliveonia
## (Intercept)              1015.03892  2836.17638   13117.588 1249530.99
## format_ITS_L6_AA$Group11 -771.60198 -2435.52833   -5719.550 -569098.54
## format_ITS_L6_AA$Group12 -650.18965 -2158.20707   -5109.044 -583890.53
## format_ITS_L6_AA$Group13 2056.98009  6804.11545    8783.563 -331679.64
## dph                       -12.81247   -21.08674    -384.175  -34857.74
##                              Exidia    Imleria Hydnomerulius Hygrophoropsis
## (Intercept)              1415.48059  66.507219     972.03339     -109.23303
## format_ITS_L6_AA$Group11 -694.17873 -24.424945    -658.31231     -138.29047
## format_ITS_L6_AA$Group12 -694.17873  50.585329    -555.79056      -83.39074
## format_ITS_L6_AA$Group13 2082.53619 -22.296621    1872.41518      352.18862
## dph                       -37.96326  -2.214857     -16.51164       13.02755
##                             Paxillus     Suillus     X__.63 Botryobasidium
## (Intercept)                883.45279  53.9633012 15517.8928      429.23965
## format_ITS_L6_AA$Group11 -1405.00499 -36.4964746 -8995.4484     -661.47531
## format_ITS_L6_AA$Group12 -1380.09549   0.5278150 -9120.2830     -245.11962
## format_ITS_L6_AA$Group13  3849.51954  72.4651341  4735.0492     1421.34682
## dph                         27.45012  -0.9193067  -336.7163       12.22293
##                          Minimedusa Sistotrema unidentified.40     X__.64
## (Intercept)                791930.8 172058.054        7.651957  656.17517
## format_ITS_L6_AA$Group11  -364382.5 -92559.935      -55.233215  712.08452
## format_ITS_L6_AA$Group12  -372705.3 -51969.981      -33.143164 -230.12052
## format_ITS_L6_AA$Group13  -261523.3  68652.094      143.609594 -240.98200
## dph                        -22025.8  -4155.788        2.504277  -21.85227
##                          Thanatephorus unidentified.41  Corticium Limonomyces
## (Intercept)                  565386.33      1066.69404  71031.591   41.639285
## format_ITS_L6_AA$Group11    -262583.98     -2353.87366 -34811.577  -21.918580
## format_ITS_L6_AA$Group12    -271675.89     -2434.31305 -34863.358   -9.577150
## format_ITS_L6_AA$Group13    -199923.88      7247.97678 -34747.901   52.017175
## dph                          -15428.96        73.32084  -1903.591   -1.037932
##                          Vuilleminia    Geastrum  Fuscoporia Hymenochaetopsis
## (Intercept)                477.39744  21995.6544  1730.79777       17.7428859
## format_ITS_L6_AA$Group11  -224.67446 -10227.1704 -1138.80274       -6.5161200
## format_ITS_L6_AA$Group12  -224.67446 -10238.0717 -1016.21477       -1.0128233
## format_ITS_L6_AA$Group13   637.91368  27539.1926  3472.40649       -6.5161200
## dph                        -13.30121   -618.8201   -21.68671       -0.5908824
##                          Peniophorella Resinicium  Trichaptum       X__.65
## (Intercept)                 18141.1470  22407.360  2915.73469  2633.484945
## format_ITS_L6_AA$Group11    -9260.0223 -38198.242 -1954.78906 -2747.415959
## format_ITS_L6_AA$Group12    -8722.7067 -37307.555 -1791.16597 -2238.305762
## format_ITS_L6_AA$Group13    27059.1321 112598.761  5637.39341  6724.162213
## dph                          -461.0341    831.099   -50.57609     5.996369
##                          Alutaceodontia Hyphodontia   Lyomyces   Oxyporus
## (Intercept)                   152.83764  3400.42631 147955.507 19.2288450
## format_ITS_L6_AA$Group11     -579.60571 -1890.56946 -69524.558 -7.0618422
## format_ITS_L6_AA$Group12     -165.68142   375.85146 -69741.554  1.4954564
## format_ITS_L6_AA$Group13     1305.30982  3038.31558 -69114.235 -7.0618422
## dph                            22.46148   -79.46615  -4110.613 -0.6403686
##                          Schizopora    Xylodon Tubulicrinis Gastrosporium
## (Intercept)              -528.58954 192.762211    36.893887    7986.17064
## format_ITS_L6_AA$Group11 -479.90171 -88.183774   -13.549374   -3796.97449
## format_ITS_L6_AA$Group12 -475.31640  83.602155   -12.759961   -3796.97449
## format_ITS_L6_AA$Group13 1435.11983 -16.799385    -6.265026      66.85191
## dph                        53.07849  -5.504128    -1.228659    -220.48401
##                             Lysurus     X__.66   Trametes unidentified.42
## (Intercept)              19707.0690  72.731973  -237.6985        48.15969
## format_ITS_L6_AA$Group11 -8733.6489 -49.190108 -1475.3859      -347.62543
## format_ITS_L6_AA$Group12 -9121.5508  -3.938199 -2363.2216      -346.93903
## format_ITS_L6_AA$Group13 -9102.6680 102.318415  3487.5357      1042.18989
## dph                       -556.2552  -1.239046   143.1544        15.76135
##                              Antrodia Cinereomyces  Fomitopsis Piptoporus
## (Intercept)               129.5887418    576.01780  5143.87321  30.852383
## format_ITS_L6_AA$Group11 -112.4626682   -385.01940 -6754.59007 -71.968515
## format_ITS_L6_AA$Group12   20.2115335   -367.29712 -5160.64523 -71.968515
## format_ITS_L6_AA$Group13  170.3802263   1133.41709 16842.43512 200.755955
## dph                        -0.9013723    -10.05255    84.77457   2.164007
##                           Tyromyces     X__.67 Perenniporia Hyphoderma
## (Intercept)              12.7162975 -10388.088   3034.90490  253.84692
## format_ITS_L6_AA$Group11 -4.6700926 -27091.650    136.21047  -72.89864
## format_ITS_L6_AA$Group12  0.9511480 -25855.778   -775.25580 -466.24587
## format_ITS_L6_AA$Group13 -4.6700926  79833.446   2086.32209  -11.05488
## dph                      -0.4234845   1972.618    -74.18386   11.17889
##                               X__.68 Climacocystis   Meripilus Rigidoporus
## (Intercept)               324.954427     113.46334  227.880940  22108.4312
## format_ITS_L6_AA$Group11 -150.324783    -154.54457 -276.355931 -27639.8873
## format_ITS_L6_AA$Group12  450.974350     -14.67503 -276.269955 -25018.2794
## format_ITS_L6_AA$Group13 -150.324783     323.76416 -276.355931  79779.3698
## dph                        -9.191034       2.16217    2.551315    291.1293
##                          unidentified.43 Bjerkandera Ceraceomyces  Ceriporia
## (Intercept)                   1220.99369  2552.31437    87.074668  -31.33611
## format_ITS_L6_AA$Group11      -629.48765 -1343.83062   -31.978394 -656.46522
## format_ITS_L6_AA$Group12      -518.96952  2404.89681    79.308621 -653.67175
## format_ITS_L6_AA$Group13      1725.32943   377.39485   -19.805872 1966.60219
## dph                            -31.04993   -57.43592    -2.899804   36.20007
##                          Hapalopilus      Irpex   Mycoacia Neofavolus
## (Intercept)               17.2306844  6080.7314  932.65209  93.783005
## format_ITS_L6_AA$Group11  -6.3280127  6372.7920 1027.55656 -34.442047
## format_ITS_L6_AA$Group12  16.2276204 -2131.6919 -342.51885 -34.442047
## format_ITS_L6_AA$Group13  -6.3280127 -2072.8926 -342.51885  98.600854
## dph                       -0.5738248  -200.6742  -31.05964  -3.123208
##                          Phanerochaete    Phlebia Phlebiopsis Porostereum
## (Intercept)                 4904.33580 10392.8499  37.6163805   611.13228
## format_ITS_L6_AA$Group11   -3193.04645 -5979.9569 -24.0824949   521.87252
## format_ITS_L6_AA$Group12   -3163.16281 -5166.4741  24.9876157  -196.26944
## format_ITS_L6_AA$Group13    8620.00248 15984.1617  20.5398782  -163.40347
## dph                          -90.06786  -232.2575  -0.7123098   -20.35223
##                          Scopuloides Hypochnicium     Fomes   Lentinus
## (Intercept)                6.8723525   152.435076  274.4929 1301.52793
## format_ITS_L6_AA$Group11  -2.5238889   -87.145202 -100.8082 -577.06988
## format_ITS_L6_AA$Group12  -2.5238889   130.479931 -100.8082 -577.06988
## format_ITS_L6_AA$Group13   2.5002360    30.808298  277.9896 1731.20965
## dph                       -0.2288665    -3.436309   -9.1413  -38.12937
##                            Rhodonia Xenasmatella Heterobasidion     X__.69
## (Intercept)                3.087322    45.029134     200.891385  31.286149
## format_ITS_L6_AA$Group11 -22.891032   -18.359860    -124.981753 -11.489918
## format_ITS_L6_AA$Group12 -22.891032    54.967564     -55.658570   7.037924
## format_ITS_L6_AA$Group13  68.171746   -18.247843     302.047808 -11.489918
## dph                        1.042301    -1.403646      -3.995244  -1.041907
##                           Peniophora Amylostereum     Stereum     X__.70
## (Intercept)               5726.03254   17.5620200  36.2539964  476.56143
## format_ITS_L6_AA$Group11 -6122.74155   -6.4496965 -21.3041448 -221.79940
## format_ITS_L6_AA$Group12 -6257.26522   -6.4496965  51.9837198  269.65932
## format_ITS_L6_AA$Group13 17696.14550   -6.4496965 -12.3943637  173.93948
## dph                         29.26772   -0.5848591  -0.7868343  -13.40853
##                            Tomentella Tomentellopsis Trechispora
## (Intercept)               25.52557266      182.95545   178.68569
## format_ITS_L6_AA$Group11  -4.84880607     -844.46145  -555.18183
## format_ITS_L6_AA$Group12  52.15882173     -848.69379  -410.34483
## format_ITS_L6_AA$Group13 -23.65500783     -848.69379  1505.34000
## dph                       -0.09845078       35.03886    19.81559
##                          Sistotremastrum unidentified.44 unidentified.45
## (Intercept)                   14123.9474       24.953775      354716.697
## format_ITS_L6_AA$Group11      -2376.1199       -9.164337     -173129.551
## format_ITS_L6_AA$Group12      -5747.4798       27.380994     -193025.825
## format_ITS_L6_AA$Group13      13631.2645       -9.052320       89119.299
## dph                            -425.0134       -0.831023       -8491.922
##                          Kurtzmanomyces Cystobasidium  Occultifur Symmetrospora
## (Intercept)                  122272.241     53770.158  2013.62978     7920.1913
## format_ITS_L6_AA$Group11     -60690.133    -20585.997 -3328.27981    -2090.3735
## format_ITS_L6_AA$Group12     -61409.138    -23828.566 -2902.74525    -4037.7801
## format_ITS_L6_AA$Group13     -47186.178     53753.161  7196.92930     6289.8196
## dph                           -3201.693     -1545.276    69.19211     -204.2023
##                           Sakaguchia Tilletiopsis      Meira Exobasidium
## (Intercept)               29249.1174   3556.96066 13733.8935  199546.230
## format_ITS_L6_AA$Group11 -13396.5891  -2126.67688 -5475.6100  -93651.513
## format_ITS_L6_AA$Group12 -13457.1783  -2100.64967 -6563.4427  -64738.538
## format_ITS_L6_AA$Group13 -12966.1223   4683.14914 17589.9025  112272.885
## dph                        -831.1547    -75.27809  -377.3921   -4822.304
##                           Golubevia Quambalaria Robbauera    Tilletia
## (Intercept)               44088.483  268.543073 6847.8730  304.856060
## format_ITS_L6_AA$Group11 -18117.678 -332.123365  467.3866 -377.033819
## format_ITS_L6_AA$Group12 -18087.534 -183.767500 -627.3492 -377.033819
## format_ITS_L6_AA$Group13  52590.530  848.014230 2277.2526 1131.101456
## dph                       -1366.884    3.346331 -227.1474    3.798829
##                          Basidioascus Geminibasidium  Malassezia
## (Intercept)                14811.2815     1818.39012  2593879.51
## format_ITS_L6_AA$Group11   -2103.5828     -739.30971 -1080550.78
## format_ITS_L6_AA$Group12   -6790.3575     -775.75278 -1396048.55
## format_ITS_L6_AA$Group13   -6790.3575     -775.75278  2856488.03
## dph                         -422.1539      -54.87565   -54873.08
##                          unidentified.46 Ustilentyloma Colacogloea
## (Intercept)                   184812.112     10123.485   5378.9209
## format_ITS_L6_AA$Group11      -27513.217     -4528.345  -2503.5820
## format_ITS_L6_AA$Group12      -98125.673     -4528.345   6070.0769
## format_ITS_L6_AA$Group13       18522.200     11501.224  -1062.9129
## dph                            -4558.921      -294.481   -151.3336
##                          Curvibasidium Rhodosporidiobolus  Rhodotorula
## (Intercept)                   7.914807         220.450540  180321.0759
## format_ITS_L6_AA$Group11    -57.130517        -105.987534 -141188.5336
## format_ITS_L6_AA$Group12    -44.196814         317.962603 -107981.7123
## format_ITS_L6_AA$Group13    158.457847        -105.987534  409223.0680
## dph                           2.590301          -6.024369     835.9367
##                          Sporobolomyces unidentified.47 Moniliella Melampsora
## (Intercept)                   690.57413        37.98130  5847.1916  4321.2808
## format_ITS_L6_AA$Group11      -84.89043      -274.15596   455.1383 -2340.0794
## format_ITS_L6_AA$Group12       17.86076      -255.47394 -3886.9911 -2340.0794
## format_ITS_L6_AA$Group13     -294.45516       803.78586  6788.3570  6486.3067
## dph                           -10.85278        12.43024  -101.5003  -104.2738
##                            Puccinia Cystofilobasidium Itersonilia    Mrakia
## (Intercept)               60.484007         2474.0557  228.266175 533.08955
## format_ITS_L6_AA$Group11 -22.212906        -4336.2627  -83.831333 -87.77645
## format_ITS_L6_AA$Group12 -16.055202        -4518.0534   -9.546762 306.08852
## format_ITS_L6_AA$Group13 -20.286466        13382.3005  163.737353 -48.26091
## dph                       -2.014269          108.1775   -7.601834 -14.41527
##                             Tausonia Filobasidium Naganishia Solicoccozyma
## (Intercept)               33071.1480    793015.26  74106.505    331410.189
## format_ITS_L6_AA$Group11   1745.8396   -429611.89  27136.827   -145017.559
## format_ITS_L6_AA$Group12 -17557.4205   -353650.07 -36020.582   -159027.365
## format_ITS_L6_AA$Group13   4963.0797    996428.48  38985.181    -83720.384
## dph                        -721.2582    -14588.42  -1899.581     -9060.244
##                             Bullera Genolevuria  Dioszegia   Hannaella
## (Intercept)               40.484805  -2626.1723  4971.5515  30979.4499
## format_ITS_L6_AA$Group11 -14.868148   5625.6144 -1797.0717 -13123.5347
## format_ITS_L6_AA$Group12 -14.868148  -1144.2865 -2486.4870 -14680.7269
## format_ITS_L6_AA$Group13  44.604443  -2240.6640 -1639.4711  30283.9572
## dph                       -1.348245    256.1493  -130.7929   -795.9105
##                          Vishniacozyma Papiliotrema Bulleromyces Cryptococcus
## (Intercept)                 130442.136     6104.123   -3194.7038    35640.989
## format_ITS_L6_AA$Group11    -54758.150   -11595.902   -2677.6149   -13743.157
## format_ITS_L6_AA$Group12    -94964.837   -10446.021   -2673.4747   -15756.029
## format_ITS_L6_AA$Group13     38032.991    31804.493    7923.5549    34489.819
## dph                          -1761.394      306.409     315.8344    -1044.195
##                          Saitozyma Apiotrichum Cutaneotrichosporon Trichosporon
## (Intercept)               109.2739   523.39805           55546.225    565825136
## format_ITS_L6_AA$Group11 -470.8173   221.30002          -15285.760   -199055295
## format_ITS_L6_AA$Group12 -470.8173   163.13851          -26256.912   -110225883
## format_ITS_L6_AA$Group13 -470.8173  -192.21927           68466.755   -108303462
## dph                        19.0286   -17.43046           -1288.981    -15995061
##                          Thecaphora  Urocystis     X__.71 Moesziomyces
## (Intercept)              1058.66623  8322.8995  97.357604    76814.958
## format_ITS_L6_AA$Group11 -530.79012 -4041.5043 -65.730799   -33790.825
## format_ITS_L6_AA$Group12 -530.79012 -3905.5607 -65.188372   -35151.109
## format_ITS_L6_AA$Group13 -507.08835 -2710.0191 196.649969   104123.696
## dph                       -27.78295  -225.2712  -1.664569    -2136.603
##                          Sporisorium Tranzscheliella   Ustilago   Wallemia
## (Intercept)               1794.69343      29711.9543  46843.267 1585250.35
## format_ITS_L6_AA$Group11   338.21070     -13631.5267 -22506.929 -790171.50
## format_ITS_L6_AA$Group12  -663.06571     -13885.1285 -23107.334 -772539.90
## format_ITS_L6_AA$Group13   -61.75641      -5476.6838  35956.591 2316350.68
## dph                        -26.76236       -821.4386  -1225.721  -41200.61
##                               X__.72 Phlyctochytrium Rhizophlyctis Powellomyces
## (Intercept)               23653.3841       229.31644    10093.7981  152.5352048
## format_ITS_L6_AA$Group11  -6416.0680       442.44292    -3059.5270 -137.4394701
## format_ITS_L6_AA$Group12 -14786.6945      -507.12899    -5524.0401 -138.1701717
## format_ITS_L6_AA$Group13  24026.3480      -507.12899    -5513.0700   51.4439530
## dph                        -462.5258        14.62171     -239.8435   -0.7560544
##                          Spizellomyces unidentified.48      X__.73  Dominikia
## (Intercept)                 11382.1956     40965.62715  2582443.96 108451.277
## format_ITS_L6_AA$Group11    -4771.0292    -40315.96325 -1196662.08 -47446.968
## format_ITS_L6_AA$Group12    -5245.7658    -38061.83490 -1230958.20 -50876.316
## format_ITS_L6_AA$Group13     1067.2249     44796.93889  -821685.84 -50288.447
## dph                          -321.0557        88.67806   -70705.14  -3025.408
##                              Glomus Rhizophagus Septoglomus Mortierella
## (Intercept)               44508.090   80323.224   59076.676  23058254.2
## format_ITS_L6_AA$Group11 -14595.098  -36415.267  -29345.558 -10610932.0
## format_ITS_L6_AA$Group12 -21019.408  -39574.712  -29850.199 -10810852.2
## format_ITS_L6_AA$Group13 -18999.238  -34355.961   21357.978  -6562969.3
## dph                       -1223.945   -2142.243   -1538.236   -638048.8
##                          unidentified.49 unidentified.50 Lichtheimia     X__.74
## (Intercept)                   3425.98820      168.127321   249.49885 1200192.84
## format_ITS_L6_AA$Group11     10622.13207     -225.118793  -308.14027 -559885.56
## format_ITS_L6_AA$Group12     -4058.28209     -225.118793  -267.28865 -557619.50
## format_ITS_L6_AA$Group13     -3296.49700      675.356379   113.32293 1675972.87
## dph                             33.27863        2.999551     3.08639  -33691.13
##                          Actinomucor     Mucor  Rhizopus   Olpidium
## (Intercept)                 5556.608  44826003 1417416.9  8878.9308
## format_ITS_L6_AA$Group11  -57658.655 -21379669 -667927.7 -4289.9207
## format_ITS_L6_AA$Group12  -57254.298 -19677317 -626161.6 -4298.9793
## format_ITS_L6_AA$Group13  161901.039  62324886 1900969.7 -4298.9793
## dph                         2764.212  -1233352  -39287.5  -241.0501
##                          unidentified.51 unidentified.52 unidentified.53
## (Intercept)                   1045.69579      2594.09539       59273.679
## format_ITS_L6_AA$Group11      -467.51838     -1504.80974      -27994.956
## format_ITS_L6_AA$Group12      -467.51838     -1505.96668      -28193.980
## format_ITS_L6_AA$Group13      -467.51838     -1505.96668      -26488.149
## dph                            -30.43039       -57.26993       -1635.774
## 
## $coef.sites
##                               D01E01C      D01E01D      D01E01I      D01E01J
## (Intercept)               0.853519105  0.860813320  0.830825980  0.830572751
## format_ITS_L6_AA$Group11 -0.047809526 -0.049943540 -0.019426284 -0.019605972
## format_ITS_L6_AA$Group12 -0.017484594 -0.031680589 -0.034746569 -0.039586035
## format_ITS_L6_AA$Group13  0.064687727  0.056493440  0.036409275  0.046853266
## dph                       0.001256681  0.001341489  0.001582966  0.001899724
##                               D01E02C       D01E02D      D01E02I      D01E02J
## (Intercept)               0.847748961  0.8973044501  0.851328092  0.830416479
## format_ITS_L6_AA$Group11 -0.031546815 -0.0213968998  0.006496110 -0.022268506
## format_ITS_L6_AA$Group12 -0.031096600 -0.0103671012 -0.023455433 -0.046822876
## format_ITS_L6_AA$Group13  0.063754292  0.0292329310  0.008882211  0.052169612
## dph                       0.001510873  0.0007871573  0.001475248  0.001884059
##                               D01E03C       D01E03D      D01E03I      D01E03J
## (Intercept)               0.878462463  0.8889492723  0.833489238  0.822645192
## format_ITS_L6_AA$Group11 -0.030509035 -0.0408052302  0.027861860  0.022101941
## format_ITS_L6_AA$Group12 -0.029061847  0.0014847180 -0.008853354 -0.016710397
## format_ITS_L6_AA$Group13  0.053488608  0.0392028124 -0.005157897  0.009060943
## dph                       0.001198791  0.0009956493  0.001265132  0.001567757
##                               D01E04C      D01E04D       D01E04I     D01E04J
## (Intercept)               0.841291809  0.840374970  0.8755506542  0.86157269
## format_ITS_L6_AA$Group11  0.002480699 -0.032570322  0.0587848180 -0.01345954
## format_ITS_L6_AA$Group12 -0.016397441 -0.026834205  0.0254818517 -0.04580167
## format_ITS_L6_AA$Group13  0.037268552  0.056947879 -0.0592379037  0.04772196
## dph                       0.001401638  0.001469832  0.0003749027  0.00141365
##                               D01E05C       D01E05D      D01E05I      D01E05J
## (Intercept)               0.833668870  0.9115427322  0.875026548  0.835357072
## format_ITS_L6_AA$Group11  0.005991619 -0.0429664151 -0.018741236 -0.017644067
## format_ITS_L6_AA$Group12 -0.004821487 -0.0161409305 -0.035750116 -0.039399976
## format_ITS_L6_AA$Group13  0.029255598  0.0470549833  0.042290165  0.038895157
## dph                       0.000853484  0.0003655815  0.001211335  0.001884231
##                                D01E06C       D01E06D       D01E06I      D01E06J
## (Intercept)               8.948025e-01  0.8879974903  0.9175599487  0.826342305
## format_ITS_L6_AA$Group11  9.396476e-03 -0.0416501785 -0.0206028908 -0.006884859
## format_ITS_L6_AA$Group12 -9.917082e-02 -0.0443097639 -0.0323322895 -0.035693289
## format_ITS_L6_AA$Group13  6.164160e-02  0.0602233837  0.0241715592  0.032550483
## dph                       8.339304e-05  0.0007475028  0.0009958248  0.001642833
##                               D01E07C      D01E07D      D01E07I      D01E07J
## (Intercept)               0.873703928  0.847300582  0.873058913  0.858837482
## format_ITS_L6_AA$Group11 -0.009497282 -0.023329783 -0.018471100  0.011090661
## format_ITS_L6_AA$Group12 -0.037765267 -0.002416509 -0.034723913 -0.023293171
## format_ITS_L6_AA$Group13  0.043236036  0.024542277  0.032941455  0.009245862
## dph                       0.001339413  0.001556350  0.001709605  0.001369394
##                               D01E08C      D01E08D      D01E08I      D01E08J
## (Intercept)               0.838413623  0.871634930  0.824584304  0.839200128
## format_ITS_L6_AA$Group11 -0.028996387 -0.043985484 -0.009788465  0.016165473
## format_ITS_L6_AA$Group12 -0.033373011 -0.031409969 -0.024792214  0.003324020
## format_ITS_L6_AA$Group13  0.053857329  0.055711323  0.030326792 -0.011580650
## dph                       0.001789823  0.001495038  0.001366831  0.001109339
##                                D01E09C       D01E09D      D01E09I      D01E09J
## (Intercept)               0.8617853799  0.9113620813  0.828220617  0.895530448
## format_ITS_L6_AA$Group11  0.0415145613 -0.0538134285 -0.015190532 -0.027816088
## format_ITS_L6_AA$Group12  0.0028429360 -0.0076623811 -0.031687165 -0.036531131
## format_ITS_L6_AA$Group13 -0.0074828762  0.0479997451  0.034752075  0.038497916
## dph                       0.0005887469  0.0005260215  0.001865328  0.001307242
##                               D01E10C       D01E10D     D01E10I       D01E10J
## (Intercept)               0.850711566  0.8849923664  0.85810007  0.9417178561
## format_ITS_L6_AA$Group11 -0.032535768 -0.0359318623 -0.02069355 -0.0225899288
## format_ITS_L6_AA$Group12 -0.012062927 -0.0002131231 -0.03588885 -0.0369975084
## format_ITS_L6_AA$Group13  0.054801580  0.0344002343  0.03688341  0.0356847625
## dph                       0.001172074  0.0010886229  0.00169958  0.0003401666
##                               D04E01C      D04E01D      D04E01I      D04E01J
## (Intercept)               0.884974503  0.853536931  0.858750533  0.836597239
## format_ITS_L6_AA$Group11  0.049444447 -0.026301677  0.061124209  0.017912973
## format_ITS_L6_AA$Group12  0.052546895  0.038830164  0.066211513 -0.111579310
## format_ITS_L6_AA$Group13 -0.056746117  0.052374465 -0.100422411  0.069652318
## dph                       0.002591746 -0.002069904  0.002593279 -0.002472996
##                               D04E02C      D04E02D      D04E02I      D04E02J
## (Intercept)               0.841701395  0.846523548  0.900154027  0.853663155
## format_ITS_L6_AA$Group11  0.074209935 -0.081595281  0.046785030 -0.045274090
## format_ITS_L6_AA$Group12  0.080485413  0.004807293  0.047999664 -0.013050131
## format_ITS_L6_AA$Group13 -0.081755378  0.099369629 -0.078873242  0.092165199
## dph                       0.002772997 -0.002146338  0.001740816 -0.002536796
##                                D04E03C       D04E03D      D04E03I      D04E03J
## (Intercept)               0.8412166492  0.8564206978  0.865281148  0.863748649
## format_ITS_L6_AA$Group11  0.0941496547 -0.0182726008  0.071719986  0.007570665
## format_ITS_L6_AA$Group12  0.0876229641  0.0036272016  0.071400116 -0.129484575
## format_ITS_L6_AA$Group13 -0.1150507093  0.0339971225 -0.121525198  0.093331528
## dph                       0.0009230001 -0.0008784493  0.001959045 -0.003118398
##                               D04E04C      D04E04D      D04E04I      D04E04J
## (Intercept)               0.862410689  0.848792850  0.850509688  0.833592160
## format_ITS_L6_AA$Group11  0.062985448 -0.074013292  0.067343407  0.055642359
## format_ITS_L6_AA$Group12  0.068250507  0.009184514  0.067162554 -0.068842555
## format_ITS_L6_AA$Group13 -0.066585846  0.080669445 -0.126307438 -0.005392226
## dph                       0.002774955 -0.001235416  0.001742078 -0.002170628
##                               D04E05C      D04E05D      D04E05I     D04E05J
## (Intercept)               0.849473377  0.870929628  0.870178055  0.83932986
## format_ITS_L6_AA$Group11  0.089130917 -0.090496341  0.068750218  0.01633651
## format_ITS_L6_AA$Group12  0.085453773 -0.000372352  0.068203920 -0.11618514
## format_ITS_L6_AA$Group13 -0.121850384  0.113614248 -0.122534041  0.06968039
## dph                       0.001442486 -0.002844160  0.001885482 -0.00229304
##                               D04E06C      D04E06D      D04E06I      D04E06J
## (Intercept)               0.864409938  0.835498522  0.907402261  0.859878838
## format_ITS_L6_AA$Group11  0.058788966 -0.009003788  0.033932038  0.083485647
## format_ITS_L6_AA$Group12  0.062809579  0.051097862  0.030111411  0.040235043
## format_ITS_L6_AA$Group13 -0.067108733  0.020659378 -0.056570278 -0.129188508
## dph                       0.002948873 -0.001512084  0.001983639 -0.001669536
##                               D04E07C      D04E07D      D04E07I       D04E07J
## (Intercept)               0.855178207  0.874875748  0.887535148  0.8381967684
## format_ITS_L6_AA$Group11  0.075499352 -0.044654810  0.047524246  0.0506454252
## format_ITS_L6_AA$Group12  0.079314415  0.023463647  0.046129350 -0.0620418409
## format_ITS_L6_AA$Group13 -0.074965191  0.049481131 -0.090450914 -0.0009074419
## dph                       0.002301632 -0.001287669  0.002111329 -0.0024884615
##                               D04E08C      D04E08D      D04E08I      D04E08J
## (Intercept)               0.868767506  0.849320519  0.881823186  0.860815349
## format_ITS_L6_AA$Group11  0.070149778 -0.083670352  0.050981202  0.009226262
## format_ITS_L6_AA$Group12  0.078880068  0.004622079  0.052880172 -0.132972932
## format_ITS_L6_AA$Group13 -0.076723776  0.088440004 -0.083188891  0.091525528
## dph                       0.001382991 -0.001395031  0.002347166 -0.002876948
##                               D04E09C       D04E09D      D04E09I      D04E09J
## (Intercept)               0.842214980  0.8550619358  0.910852991  0.878441913
## format_ITS_L6_AA$Group11  0.072456036 -0.0364045722  0.047722852 -0.002695937
## format_ITS_L6_AA$Group12  0.080872198  0.0107682130  0.045049805 -0.151943721
## format_ITS_L6_AA$Group13 -0.080100981  0.0349174729 -0.077743468  0.109468158
## dph                       0.002893367 -0.0001124694  0.001593407 -0.003100246
##                               D04E10C       D04E10D      D04E10I      D04E10J
## (Intercept)               0.840665461  0.8428102272  0.881278915  0.873069256
## format_ITS_L6_AA$Group11  0.076393528  0.0155321205  0.067915724 -0.010674685
## format_ITS_L6_AA$Group12  0.087536478  0.0407914455  0.064316724 -0.148882552
## format_ITS_L6_AA$Group13 -0.086839558 -0.0155082884 -0.087892197  0.110841669
## dph                       0.002294628 -0.0008728785  0.001712995 -0.002562466
##                               D07E01C      D07E01D      D07E01I      D07E01J
## (Intercept)               0.870700504  0.841249146  0.834153903  0.823071604
## format_ITS_L6_AA$Group11  0.053196653 -0.058672012  0.096820693  0.066596452
## format_ITS_L6_AA$Group12  0.059733228  0.022609452  0.054925140 -0.068508657
## format_ITS_L6_AA$Group13 -0.060303635  0.078031508 -0.132757151 -0.009068583
## dph                       0.002929803 -0.001702839 -0.001188997 -0.001966140
##                                D07E02C      D07E02D      D07E02I      D07E02J
## (Intercept)               0.9739773030  0.866426130  0.842363598  0.866831406
## format_ITS_L6_AA$Group11  0.0109943720  0.022566287  0.090461828 -0.011717234
## format_ITS_L6_AA$Group12  0.0082656134  0.055308816  0.059450117 -0.122744093
## format_ITS_L6_AA$Group13 -0.0034046186 -0.058124649 -0.129969913  0.102972681
## dph                       0.0006715226  0.001079832 -0.001234418 -0.002603556
##                               D07E03C      D07E03D      D07E03I      D07E03J
## (Intercept)               0.855483915  0.839072769  0.868631562  0.886810647
## format_ITS_L6_AA$Group11  0.086381723 -0.037940720  0.085435760 -0.040679164
## format_ITS_L6_AA$Group12  0.081276809  0.009657969  0.068933358 -0.123287396
## format_ITS_L6_AA$Group13 -0.094589172  0.083726934 -0.132958265  0.118159079
## dph                       0.001565507 -0.002813595 -0.000178477 -0.003059772
##                                D07E04C     D07E04D      D07E04I      D07E04J
## (Intercept)               0.8557980345  0.83894852  0.954546489  0.883187904
## format_ITS_L6_AA$Group11  0.0773754090 -0.03042502  0.019619698  0.063251705
## format_ITS_L6_AA$Group12  0.0898837408 -0.01266482  0.018183780  0.005245624
## format_ITS_L6_AA$Group13 -0.0855421137  0.06402315 -0.032304673 -0.053573435
## dph                       0.0007622582 -0.00205928  0.001054448 -0.001852619
##                                D07E05C      D07E05D       D07E05I      D07E05J
## (Intercept)               8.525022e-01  0.834807669  0.8713605052  0.815941269
## format_ITS_L6_AA$Group11  8.638137e-02 -0.011400465  0.0755522604  0.046764459
## format_ITS_L6_AA$Group12  8.010510e-02  0.042635898  0.0620491023 -0.058060969
## format_ITS_L6_AA$Group13 -9.193465e-02  0.047155088 -0.1363417608  0.017461212
## dph                       3.445454e-06 -0.002374114  0.0001446221 -0.002176619
##                              D07E06C       D07E06D       D07E06I      D07E06J
## (Intercept)               0.96112496  0.8635378937  8.508992e-01  0.841840427
## format_ITS_L6_AA$Group11  0.01514613  0.0262876125  3.255465e-02  0.040478901
## format_ITS_L6_AA$Group12  0.01075631  0.0592101148  2.976008e-02 -0.095467675
## format_ITS_L6_AA$Group13 -0.00756952 -0.0611147047 -4.084459e-02  0.040610084
## dph                       0.00100587  0.0009302425 -6.144961e-05 -0.002780954
##                               D07E07C      D07E07D      D07E07I       D07E07J
## (Intercept)               0.853448251  0.922041277  0.883034926  8.660457e-01
## format_ITS_L6_AA$Group11  0.041612130  0.018943641  0.005484123  5.680473e-02
## format_ITS_L6_AA$Group12  0.073130130  0.020664934  0.010196194  3.820739e-02
## format_ITS_L6_AA$Group13 -0.025703434 -0.034784793 -0.027183924 -1.102873e-01
## dph                      -0.001848901  0.001783873  0.001090659 -9.406525e-05
##                                D07E08C      D07E08D     D07E08I      D07E08J
## (Intercept)               0.8460039892  0.855623363  0.89967064  0.922665552
## format_ITS_L6_AA$Group11  0.0870817684  0.047813409  0.01888347  0.023864389
## format_ITS_L6_AA$Group12  0.0724092301  0.016477516  0.02934003  0.019873391
## format_ITS_L6_AA$Group13 -0.0962177048 -0.072238071 -0.05331487 -0.048521501
## dph                      -0.0008982709 -0.000397844  0.00215950  0.001539236
##                               D07E09C      D07E09D      D07E09I      D07E09J
## (Intercept)               0.837654318  0.894974673  0.872046029  0.943568045
## format_ITS_L6_AA$Group11  0.078960827  0.023728449  0.052197336  0.021928056
## format_ITS_L6_AA$Group12  0.089998327  0.039863875  0.050394681  0.010821750
## format_ITS_L6_AA$Group13 -0.103572371 -0.056027721 -0.108013920 -0.032407588
## dph                       0.001003811  0.002066986  0.001653769  0.001221091
##                               D07E10C       D07E10D      D07E10I       D07E10J
## (Intercept)               0.849191830  0.8546986062  0.877275175  0.8383522141
## format_ITS_L6_AA$Group11  0.067112123  0.0267624758  0.057509150  0.0550841531
## format_ITS_L6_AA$Group12  0.076306293  0.0657511244  0.058999351 -0.0088102602
## format_ITS_L6_AA$Group13 -0.074178991 -0.0560223512 -0.105175385 -0.0589792671
## dph                       0.002971961  0.0004692518  0.002156442 -0.0002864764
##                              D14E01C       D14E01D       D14E01I      D14E01J
## (Intercept)               0.87252277  0.8625588948  0.8763318786  0.844190461
## format_ITS_L6_AA$Group11  0.04734494 -0.0529335803  0.0911244985  0.093482144
## format_ITS_L6_AA$Group12  0.05702979  0.0158974354  0.0529927812 -0.015394778
## format_ITS_L6_AA$Group13 -0.08044924  0.0438423637 -0.1508733886 -0.085983097
## dph                       0.00255822 -0.0002003782 -0.0009419073 -0.001730083
##                               D14E02C      D14E02D       D14E02I      D14E02J
## (Intercept)               0.851353673  0.855145425  8.232360e-01  0.812886457
## format_ITS_L6_AA$Group11  0.054059297 -0.073136990  4.128462e-02  0.068805015
## format_ITS_L6_AA$Group12  0.073613702  0.011557524 -5.901974e-03 -0.063962317
## format_ITS_L6_AA$Group13 -0.056938175  0.092182951 -1.187385e-02 -0.001478985
## dph                      -0.001264585 -0.002365497 -4.194481e-05 -0.001964074
##                               D14E03C      D14E03D       D14E03I       D14E03J
## (Intercept)               0.845951517  0.931307575  0.9213773042  0.8132495062
## format_ITS_L6_AA$Group11  0.034128127 -0.085897353  0.0473707545  0.0630146714
## format_ITS_L6_AA$Group12  0.051520631 -0.032501583  0.0439549991 -0.0527608951
## format_ITS_L6_AA$Group13 -0.006289219  0.074286088 -0.0846441225 -0.0005044097
## dph                      -0.002187915 -0.001476698  0.0009936317 -0.0014035956
##                               D14E04C       D14E04D       D14E04I      D14E04J
## (Intercept)               0.850597331  0.9481375248  0.8230138764  0.847713697
## format_ITS_L6_AA$Group11  0.067695873 -0.0719206734  0.0708006885 -0.009588584
## format_ITS_L6_AA$Group12  0.084043006 -0.0235902343  0.0515319753 -0.145753770
## format_ITS_L6_AA$Group13 -0.078835536  0.0561576164 -0.0936631731  0.110984056
## dph                      -0.001123454 -0.0009340947 -0.0002841143 -0.001944845
##                               D14E05C       D14E05D       D14E05I      D14E05J
## (Intercept)               0.833353720  0.9592485962  0.8874207457  0.870134072
## format_ITS_L6_AA$Group11  0.057205770 -0.0535623900  0.0774378052  0.078576535
## format_ITS_L6_AA$Group12  0.044009692 -0.0303271196  0.0685858545 -0.007803613
## format_ITS_L6_AA$Group13 -0.043588887  0.0467347590 -0.1303577565 -0.066117677
## dph                      -0.001377311 -0.0007705051  0.0007589505 -0.003166066
##                                D14E06C      D14E06D      D14E06I      D14E06J
## (Intercept)               0.8292216773  0.889968672  0.836869680  0.846571356
## format_ITS_L6_AA$Group11  0.0671580325 -0.116527583  0.092632928  0.038454154
## format_ITS_L6_AA$Group12  0.0389998730 -0.020920326  0.062449099 -0.099239461
## format_ITS_L6_AA$Group13 -0.0634863755  0.112598401 -0.145903243  0.045586383
## dph                      -0.0008170734 -0.002688298 -0.001147547 -0.002818017
##                               D14E07C      D14E07D       D14E07I      D14E07J
## (Intercept)               0.837145192  0.942698961  0.8746690794  0.853778015
## format_ITS_L6_AA$Group11  0.036327025 -0.083611696  0.0762851005  0.045173103
## format_ITS_L6_AA$Group12  0.036037429 -0.030817848  0.0470102411 -0.093004396
## format_ITS_L6_AA$Group13  0.004200393  0.068241216 -0.1055621223  0.035115016
## dph                      -0.001738570 -0.001396625  0.0001188886 -0.003103583
##                               D14E08C       D14E08D      D14E08I      D14E08J
## (Intercept)               0.823968337  0.9504526842  0.858836538  0.918859297
## format_ITS_L6_AA$Group11 -0.027798624 -0.0626116681  0.095030090 -0.020270360
## format_ITS_L6_AA$Group12  0.004488340 -0.0198564032  0.065611483 -0.139455296
## format_ITS_L6_AA$Group13  0.069446554  0.0496002893 -0.136790364  0.097685197
## dph                      -0.001576867 -0.0005927263 -0.001584801 -0.002451022
##                               D14E09C      D14E09D       D14E09I      D14E09J
## (Intercept)               0.859247503  0.929404048  8.542639e-01  0.890978718
## format_ITS_L6_AA$Group11  0.060160939 -0.086990851  9.120065e-02 -0.020734722
## format_ITS_L6_AA$Group12  0.063261531 -0.032067062  7.102646e-02 -0.121506898
## format_ITS_L6_AA$Group13 -0.056736369  0.082344550 -1.335548e-01  0.089107356
## dph                      -0.001152606 -0.001883294 -3.106563e-05 -0.001212376
##                               D14E10C      D14E10D      D14E10I      D14E10J
## (Intercept)               0.864638723  0.919155038  0.877561397  0.959865231
## format_ITS_L6_AA$Group11  0.084336486 -0.098289326  0.087574374 -0.005010275
## format_ITS_L6_AA$Group12  0.004581369 -0.026223184  0.055745329 -0.093457666
## format_ITS_L6_AA$Group13 -0.080820333  0.080849045 -0.129493490  0.053529324
## dph                      -0.003067771 -0.001452411 -0.001709481 -0.001212540
##                               D21E01C       D21E01D      D21E01I      D21E01J
## (Intercept)               0.852905622  0.8754765948  0.876036921  0.842051798
## format_ITS_L6_AA$Group11  0.043936747  0.0476338078  0.051246521  0.067697104
## format_ITS_L6_AA$Group12  0.056628011  0.0714425300  0.048837448 -0.025787450
## format_ITS_L6_AA$Group13 -0.027844827 -0.0734258245 -0.093195183 -0.033274732
## dph                      -0.001130148 -0.0003980018  0.001037376 -0.001436227
##                               D21E02C      D21E02D      D21E02I      D21E02J
## (Intercept)               0.854685749  0.896543511  0.849942319  0.909877427
## format_ITS_L6_AA$Group11 -0.002849147 -0.098329130  0.096830150 -0.018264881
## format_ITS_L6_AA$Group12  0.048011588 -0.013615922  0.045102085 -0.131879244
## format_ITS_L6_AA$Group13  0.034158322  0.096299531 -0.118368097  0.089536889
## dph                      -0.002335090 -0.002132792 -0.001526166 -0.001728578
##                               D21E03C     D21E03D      D21E03I      D21E03J
## (Intercept)               0.857985519  0.94217890  0.819466215  0.919391043
## format_ITS_L6_AA$Group11 -0.057778098 -0.08358648  0.018175325 -0.024182683
## format_ITS_L6_AA$Group12  0.020742309 -0.02938079 -0.018003118 -0.135244353
## format_ITS_L6_AA$Group13  0.086377874  0.06889486  0.032183233  0.096077276
## dph                      -0.002402582 -0.00137869 -0.001783845 -0.002314647
##                               D21E04C       D21E04D       D21E04I      D21E04J
## (Intercept)               0.885071437  0.9583752381  0.8744310900  0.945092913
## format_ITS_L6_AA$Group11 -0.007207151 -0.0531680791  0.0867030819 -0.010762221
## format_ITS_L6_AA$Group12 -0.153599135 -0.0319917557  0.0767374048 -0.120515954
## format_ITS_L6_AA$Group13  0.109376167  0.0465183195 -0.1371266483  0.073910730
## dph                      -0.002834174 -0.0007578833  0.0005131472 -0.001870579
##                               D21E05C      D21E05D      D21E05I      D21E05J
## (Intercept)               0.835939703  0.906155128  0.839831900  0.894397593
## format_ITS_L6_AA$Group11  0.036672256 -0.103321413  0.077181927 -0.020350188
## format_ITS_L6_AA$Group12  0.028541776 -0.005989036 -0.010788807 -0.135768905
## format_ITS_L6_AA$Group13  0.009783122  0.086726692 -0.050626008  0.096969317
## dph                      -0.002171244 -0.001779406 -0.003031844 -0.001690309
##                               D21E06C      D21E06D      D21E06I       D21E06J
## (Intercept)               0.841988700  0.913295731  0.874707451  0.9878899241
## format_ITS_L6_AA$Group11  0.047595647 -0.112518792  0.077275279  0.0013969680
## format_ITS_L6_AA$Group12  0.040270014 -0.011782052  0.072343360 -0.0286894190
## format_ITS_L6_AA$Group13 -0.015689942  0.092696480 -0.118715801  0.0140778822
## dph                      -0.002042444 -0.002305051  0.001420929 -0.0002337038
##                               D21E07C      D21E07D      D21E07I      D21E07J
## (Intercept)               0.846900766  0.870204778  0.903094397  0.955295255
## format_ITS_L6_AA$Group11  0.088033790 -0.091450385  0.073444450 -0.006941196
## format_ITS_L6_AA$Group12  0.064404414 -0.008245619  0.059662129 -0.098222623
## format_ITS_L6_AA$Group13 -0.094735148  0.114929771 -0.119335847  0.057586569
## dph                      -0.001343842 -0.002865936 -0.000533802 -0.001279310
##                                D21E08C      D21E08D     D21E08I       D21E08J
## (Intercept)               0.8394705603  0.869224864  0.88580997  0.9596015248
## format_ITS_L6_AA$Group11  0.0268101972 -0.023856079  0.07389657 -0.0090674987
## format_ITS_L6_AA$Group12  0.0530821971  0.039213098  0.03651909 -0.0640230313
## format_ITS_L6_AA$Group13  0.0009716771  0.047114251 -0.09010288  0.0404762545
## dph                      -0.0017815315 -0.002280411 -0.00204224 -0.0005543874
##                                D21E09C      D21E09D      D21E09I      D21E09J
## (Intercept)               0.8267978269  0.916869202  0.858582815  0.904961758
## format_ITS_L6_AA$Group11  0.0300198004 -0.098225057  0.103182062 -0.020651737
## format_ITS_L6_AA$Group12  0.0484770132 -0.036197965  0.078693253 -0.142721825
## format_ITS_L6_AA$Group13 -0.0113929507  0.090513705 -0.154454527  0.101607638
## dph                      -0.0009431637 -0.001891076 -0.000948761 -0.002326766
##                               D21E10C      D21E10D      D21E10I      D21E10J
## (Intercept)               0.869149734  0.867390816  0.864115592  0.902712043
## format_ITS_L6_AA$Group11  0.024263066 -0.095146037  0.088119219 -0.029923196
## format_ITS_L6_AA$Group12  0.050028971 -0.015649200  0.058114084 -0.138411565
## format_ITS_L6_AA$Group13  0.001769154  0.108321762 -0.109125001  0.108226232
## dph                      -0.002228113 -0.002129184 -0.001930073 -0.002649733
##                               D28E01C      D28E01D       D28E01I      D28E01J
## (Intercept)               0.855344053  0.958229116  0.8683807735  0.945030249
## format_ITS_L6_AA$Group11 -0.021879568 -0.056120016  0.0891083409 -0.014949232
## format_ITS_L6_AA$Group12  0.037089760 -0.031008111  0.0627897366 -0.104046789
## format_ITS_L6_AA$Group13  0.054377589  0.048826489 -0.1262473013  0.065731938
## dph                      -0.002538689 -0.000945918 -0.0008570755 -0.001415419
##                               D28E02C      D28E02D      D28E02I       D28E02J
## (Intercept)               0.870087671  0.867693666  0.858840161  0.9613468621
## format_ITS_L6_AA$Group11 -0.097344920 -0.053009056  0.082942329 -0.0005118123
## format_ITS_L6_AA$Group12 -0.004126599 -0.003340030  0.051580370 -0.0909330015
## format_ITS_L6_AA$Group13  0.111592122  0.081921563 -0.092591092  0.0497751910
## dph                      -0.002729964 -0.002551783 -0.001987861 -0.0010969510
##                               D28E03C      D28E03D      D28E03I      D28E03J
## (Intercept)               0.857935830  0.940944131  0.847607431  0.863494065
## format_ITS_L6_AA$Group11  0.001935263 -0.070593914  0.090777162  0.005188419
## format_ITS_L6_AA$Group12  0.043065914 -0.041856122  0.005388319 -0.151662545
## format_ITS_L6_AA$Group13  0.033966895  0.068872303 -0.086577462  0.101792430
## dph                      -0.002355407 -0.001427281 -0.002124477 -0.002667098
##                               D28E04C      D28E04D      D28E04I     D28E04J
## (Intercept)               0.859177182  0.931196558  0.870068084  0.83583656
## format_ITS_L6_AA$Group11 -0.027090904 -0.075929082  0.099676700  0.02061922
## format_ITS_L6_AA$Group12  0.024670550  0.008811633  0.044964405 -0.12272641
## format_ITS_L6_AA$Group13  0.067839019  0.064434540 -0.141858895  0.07516887
## dph                      -0.002529836 -0.001926785 -0.001873465 -0.00162810
##                               D28E05C      D28E05D      D28E05I      D28E05J
## (Intercept)               0.857949593  0.873518359  0.832524914  0.878124449
## format_ITS_L6_AA$Group11  0.045185584 -0.063108774  0.067917384 -0.020513899
## format_ITS_L6_AA$Group12  0.030177029  0.020277103 -0.006848330 -0.140187092
## format_ITS_L6_AA$Group13 -0.007198961  0.077419548 -0.030883651  0.105541114
## dph                      -0.002520606 -0.002383147 -0.002862973 -0.001917263
##                               D28E06C      D28E06D      D28E06I      D28E06J
## (Intercept)               0.857065590  0.863492326  0.830638729  0.865171788
## format_ITS_L6_AA$Group11 -0.071185339 -0.082060008 -0.034944474 -0.001595073
## format_ITS_L6_AA$Group12  0.010546772  0.017212365 -0.041867870 -0.151109319
## format_ITS_L6_AA$Group13  0.099371541  0.096747837  0.068878597  0.109591164
## dph                      -0.002487853 -0.002564157 -0.000222828 -0.002804566
##                               D28E07C      D28E07D      D28E07I      D28E07J
## (Intercept)               0.847959454  0.904397685  0.853687230  0.946790057
## format_ITS_L6_AA$Group11 -0.032396587 -0.100440508 -0.047869668 -0.049339267
## format_ITS_L6_AA$Group12 -0.006328036  0.001456906 -0.035793152 -0.070369733
## format_ITS_L6_AA$Group13  0.079915568  0.088024432  0.078738751  0.069364348
## dph                      -0.002461419 -0.002226826 -0.001611073 -0.001537693
##                               D28E08C      D28E08D      D28E08I      D28E08J
## (Intercept)               0.848877707  0.863445655  0.863664027  0.879843701
## format_ITS_L6_AA$Group11 -0.017169583 -0.080055213  0.091537955 -0.006991258
## format_ITS_L6_AA$Group12  0.033606877 -0.034446123  0.051412174 -0.153457002
## format_ITS_L6_AA$Group13  0.054473418  0.106824503 -0.142535651  0.111166767
## dph                      -0.002374852 -0.002375908 -0.001661672 -0.002869651
##                               D28E09C      D28E09D      D28E09I      D28E09J
## (Intercept)               0.872331882  0.944854435  0.848396378  0.932656936
## format_ITS_L6_AA$Group11  0.050399684 -0.069227856  0.083967876 -0.017297374
## format_ITS_L6_AA$Group12  0.066229217 -0.010136285  0.035671536 -0.126439257
## format_ITS_L6_AA$Group13 -0.043308384  0.053330844 -0.093814278  0.082695762
## dph                      -0.001591121 -0.001301219 -0.002508501 -0.001955762
##                               D28E10C      D28E10D       D28E10I      D28E10J
## (Intercept)               0.855027897  0.889566822  0.8497433416  0.871238740
## format_ITS_L6_AA$Group11 -0.045980235 -0.084351868 -0.0059117606 -0.006399453
## format_ITS_L6_AA$Group12  0.023399603 -0.003628621 -0.0115934452 -0.142081972
## format_ITS_L6_AA$Group13  0.080335946  0.093593456  0.0379687015  0.101421983
## dph                      -0.002469787 -0.002082512 -0.0009895948 -0.001837363
##                              D35E01C      D35E01D      D35E01I      D35E01J
## (Intercept)               0.88799146  0.863426310  0.822830830  0.862337761
## format_ITS_L6_AA$Group11 -0.09552833 -0.091366559  0.068144334 -0.009123578
## format_ITS_L6_AA$Group12 -0.01567709  0.009404684 -0.013521169 -0.148637556
## format_ITS_L6_AA$Group13  0.11261330  0.099354570 -0.023355547  0.111921282
## dph                      -0.00282365 -0.002506113 -0.002998382 -0.002323700
##                                D35E02C      D35E02D      D35E02I      D35E02J
## (Intercept)               0.8522615024  0.910621122  0.826910455  0.886712734
## format_ITS_L6_AA$Group11  0.0007950224 -0.110381292  0.065499064 -0.021714151
## format_ITS_L6_AA$Group12  0.0467366392 -0.024418800  0.003384064 -0.140272323
## format_ITS_L6_AA$Group13  0.0375685454  0.098123455 -0.057965134  0.114574936
## dph                      -0.0025090024 -0.002239224 -0.002188895 -0.003078734
##                               D35E03C      D35E03D       D35E03I      D35E03J
## (Intercept)               0.850926430  0.908109875  0.9267233021  0.845643339
## format_ITS_L6_AA$Group11 -0.023302687 -0.046875549  0.0497429135  0.024892607
## format_ITS_L6_AA$Group12  0.032285562  0.005049699  0.0436267437 -0.121026712
## format_ITS_L6_AA$Group13  0.068665518  0.065069097 -0.0862676113  0.069060399
## dph                      -0.002742199 -0.002205689  0.0007905127 -0.002628012
##                               D35E04C      D35E04D      D35E04I       D35E04J
## (Intercept)               0.865852952  0.943453950  0.846164586  0.9722195943
## format_ITS_L6_AA$Group11 -0.075397531 -0.097495021  0.013609489 -0.0002654791
## format_ITS_L6_AA$Group12  0.009139609 -0.015871572  0.042997258 -0.0594134727
## format_ITS_L6_AA$Group13  0.107134365  0.077575333  0.012377485  0.0323257475
## dph                      -0.002901032 -0.002097536 -0.002060285 -0.0006121312
##                               D35E05C      D35E05D      D35E05I      D35E05J
## (Intercept)               0.910234610  0.909484473  0.862580140  0.869954557
## format_ITS_L6_AA$Group11 -0.101925483 -0.092482271  0.084893668  0.096067583
## format_ITS_L6_AA$Group12 -0.021604284 -0.016732403 -0.065434565  0.036297947
## format_ITS_L6_AA$Group13  0.101937425  0.080869974 -0.039034068 -0.125752686
## dph                      -0.002533096 -0.001379515 -0.002137424 -0.002775396
##                               D35E06C      D35E06D       D35E06I      D35E06J
## (Intercept)               0.855655185  0.910106684  0.8596920285  0.889627491
## format_ITS_L6_AA$Group11 -0.042995612 -0.105708046  0.0100144319 -0.006799465
## format_ITS_L6_AA$Group12  0.028064436 -0.029670464 -0.0529104481 -0.009050971
## format_ITS_L6_AA$Group13  0.083885605  0.102683516  0.0364215597  0.047556164
## dph                      -0.002761123 -0.002552617 -0.0007123053 -0.002094245
##                                D35E07C      D35E07D      D35E07I       D35E07J
## (Intercept)               0.8555022626  0.925042290  0.866188564  0.8794073027
## format_ITS_L6_AA$Group11  0.0957654140 -0.101883147  0.085365826 -0.0008267391
## format_ITS_L6_AA$Group12  0.0819858666 -0.015044722  0.046089834 -0.1526329405
## format_ITS_L6_AA$Group13 -0.1164534786  0.086430180 -0.098588854  0.1075682867
## dph                      -0.0005308151 -0.002071479 -0.002360142 -0.0031271158
##                               D35E08C      D35E08D      D35E08I       D35E08J
## (Intercept)               0.849082745  0.870049200  0.883107456  8.742070e-01
## format_ITS_L6_AA$Group11 -0.031211623 -0.055073091  0.087318727  4.566174e-05
## format_ITS_L6_AA$Group12  0.014700158 -0.020253890  0.056348045 -1.469316e-01
## format_ITS_L6_AA$Group13  0.083420836  0.084447896 -0.131488774  1.051205e-01
## dph                      -0.002978702 -0.002049356 -0.002179624 -3.062091e-03
##                               D35E09C      D35E09D      D35E09I      D35E09J
## (Intercept)               0.880255462  0.917373786  0.845521270  0.955400310
## format_ITS_L6_AA$Group11 -0.091806674 -0.100560011  0.078959240 -0.007842568
## format_ITS_L6_AA$Group12 -0.004764577 -0.025032637  0.020070779 -0.100379638
## format_ITS_L6_AA$Group13  0.113259566  0.085969930 -0.072421688  0.059193450
## dph                      -0.002901426 -0.001688792 -0.003145416 -0.001388040
##                               D35E10C      D35E10D     D35E10I      D35E10J
## (Intercept)               0.863835503  0.866651495  0.85510888  0.880499081
## format_ITS_L6_AA$Group11 -0.079548099 -0.028786774  0.09352828 -0.009565468
## format_ITS_L6_AA$Group12  0.008133693 -0.031052818  0.05807645 -0.147774198
## format_ITS_L6_AA$Group13  0.109715862  0.077256669 -0.12639849  0.109962210
## dph                      -0.002927213 -0.002837898 -0.00259616 -0.002891753
##                               D42E01C      D42E01D      D42E01I      D42E01J
## (Intercept)               0.863981495  0.877684724  0.834431753  0.835111851
## format_ITS_L6_AA$Group11 -0.088461816 -0.105506194  0.080170178 -0.010437815
## format_ITS_L6_AA$Group12  0.003114213 -0.007140669  0.041402877 -0.102129162
## format_ITS_L6_AA$Group13  0.109631511  0.110012509 -0.084994382  0.094801580
## dph                      -0.002913969 -0.002878317 -0.001914861 -0.002048067
##                               D42E02C       D42E02D       D42E02I      D42E02J
## (Intercept)               0.859159691  0.8636940390  0.8512118327  0.916490532
## format_ITS_L6_AA$Group11  0.075590531 -0.0213872816  0.0824100816 -0.027192402
## format_ITS_L6_AA$Group12  0.030711588 -0.0006629447  0.0814720287 -0.133070476
## format_ITS_L6_AA$Group13 -0.065151185  0.0649054806 -0.1358942729  0.097430143
## dph                      -0.003229323 -0.0031201966  0.0009390612 -0.002275684
##                               D42E03C      D42E03D      D42E03I      D42E03J
## (Intercept)               0.878248716  0.908848545  0.901731899  0.857714354
## format_ITS_L6_AA$Group11  0.083802936 -0.088046900  0.081157707  0.065553867
## format_ITS_L6_AA$Group12  0.031473624 -0.013729178  0.041717785 -0.049905815
## format_ITS_L6_AA$Group13 -0.101024761  0.081513976 -0.131450055 -0.018784798
## dph                      -0.003079503 -0.001896667 -0.002189763 -0.003269043
##                               D42E04C      D42E04D      D42E04I      D42E04J
## (Intercept)               0.887126246  0.872410089  0.861760362  0.918457089
## format_ITS_L6_AA$Group11  0.047967461 -0.077891993  0.094143442 -0.030151047
## format_ITS_L6_AA$Group12  0.017391499 -0.001827765  0.074813535 -0.117469232
## format_ITS_L6_AA$Group13 -0.017971151  0.101620071 -0.137956203  0.087242609
## dph                      -0.002730796 -0.002781241 -0.001543716 -0.001755467
##                               D42E05C      D42E05D      D42E05I      D42E05J
## (Intercept)               0.950937525  0.862133071  0.888322502  0.868647694
## format_ITS_L6_AA$Group11  0.026803265  0.056737633  0.091272217  0.006878661
## format_ITS_L6_AA$Group12  0.012352315  0.046200652  0.066958017 -0.136430927
## format_ITS_L6_AA$Group13 -0.013372812 -0.042227537 -0.145594565  0.095989632
## dph                      -0.001688206 -0.002579526 -0.001815037 -0.003136500
##                               D42E06C      D42E06D     D42E06I      D42E06J
## (Intercept)               0.883183157  0.866146343  0.92243817  0.855221093
## format_ITS_L6_AA$Group11  0.005609919  0.005451547  0.05814280  0.058420762
## format_ITS_L6_AA$Group12 -0.015791257  0.002180985  0.05109874 -0.073934974
## format_ITS_L6_AA$Group13  0.041526340  0.038361014 -0.10596217  0.004873782
## dph                      -0.003224203 -0.002939707  0.00020670 -0.003186316
##                               D42E07C      D42E07D      D42E07I      D42E07J
## (Intercept)               0.963762644  0.883806165  0.896153330  0.851748618
## format_ITS_L6_AA$Group11  0.013964184  0.086669829  0.088345078  0.061227638
## format_ITS_L6_AA$Group12  0.031039659  0.018669220  0.061330181 -0.086809212
## format_ITS_L6_AA$Group13 -0.009946104 -0.109023278 -0.147680931  0.009905399
## dph                      -0.001557722 -0.002943805 -0.001659906 -0.002955663
##                               D42E08C      D42E08D      D42E08I      D42E08J
## (Intercept)               0.856082371  0.919813069  0.867233814  0.946670913
## format_ITS_L6_AA$Group11 -0.090751258 -0.075658459  0.092214374 -0.014566656
## format_ITS_L6_AA$Group12 -0.018656310 -0.021843880  0.073141013 -0.113109615
## format_ITS_L6_AA$Group13  0.113836423  0.079983063 -0.146062921  0.071447751
## dph                      -0.002397819 -0.002136246 -0.001171094 -0.001774205
##                               D42E09C      D42E09D      D42E09I      D42E09J
## (Intercept)               0.868629867  0.915572998  0.858605150  0.868024558
## format_ITS_L6_AA$Group11 -0.077638860 -0.020073498  0.100987905 -0.009135641
## format_ITS_L6_AA$Group12 -0.011498449 -0.141881536  0.059873000 -0.100116244
## format_ITS_L6_AA$Group13  0.096703667  0.099957168 -0.140441873  0.084362128
## dph                      -0.002441524 -0.002525543 -0.002340961 -0.001404839
##                               D42E10C      D42E10D       D42E10I      D42E10J
## (Intercept)               0.852730423  0.876442310  0.9050953096  0.834753386
## format_ITS_L6_AA$Group11  0.030011986  0.004397323  0.0746939262  0.081766377
## format_ITS_L6_AA$Group12 -0.096875727 -0.079204733  0.0608037129 -0.031414886
## format_ITS_L6_AA$Group13  0.057294284  0.062858395 -0.1369979043 -0.042423506
## dph                      -0.003138854 -0.002717160 -0.0001381836 -0.002651069
## 
## $f.perms
##              [,1]      [,2]
##    [1,] 0.8737243 1.9526002
##    [2,] 0.9447323 0.8604679
##    [3,] 0.9084097 0.6141362
##    [4,] 0.8845067 0.5136875
##    [5,] 0.7584404 0.5537687
##    [6,] 0.9033924 1.4087562
##    [7,] 0.8766036 1.0249130
##    [8,] 1.2278335 0.7509370
##    [9,] 1.2767513 1.1378611
##   [10,] 0.8925605 0.9252163
##   [11,] 1.2646821 0.5214339
##   [12,] 0.8101541 1.3330005
##   [13,] 0.7444939 0.9857083
##   [14,] 0.7614165 0.4679046
##   [15,] 0.7535189 0.7918731
##   [16,] 0.7128113 0.8030003
##   [17,] 0.8947160 0.7071822
##   [18,] 0.9790907 0.8274321
##   [19,] 1.0477017 0.8362879
##   [20,] 0.9810311 1.8898222
##   [21,] 1.0915393 0.7337966
##   [22,] 0.6942630 1.4156520
##   [23,] 1.0224268 1.6591572
##   [24,] 0.7198405 0.9492752
##   [25,] 0.6389224 0.7865539
##   [26,] 0.9879350 0.8616447
##   [27,] 0.7881506 0.6548022
##   [28,] 1.4895994 1.6607652
##   [29,] 0.7072474 1.1461718
##   [30,] 1.0062762 0.5820477
##   [31,] 0.7663710 0.9158222
##   [32,] 1.3434722 1.5177764
##   [33,] 1.3780299 0.7879867
##   [34,] 0.8673138 0.7710359
##   [35,] 0.9696249 0.7104769
##   [36,] 0.9759185 1.0927000
##   [37,] 1.1256470 1.4620667
##   [38,] 0.8686718 0.9823628
##   [39,] 0.6473341 0.6850850
##   [40,] 1.0960640 0.4701323
##   [41,] 1.0010547 1.1812894
##   [42,] 0.7465705 1.4771835
##   [43,] 0.9363093 1.0976342
##   [44,] 0.7519176 0.4637591
##   [45,] 1.1924710 0.7875210
##   [46,] 0.9523901 0.9296467
##   [47,] 0.8564745 0.7287079
##   [48,] 0.6899905 0.7943756
##   [49,] 0.8534177 1.3564423
##   [50,] 1.0147480 1.0313809
##   [51,] 0.8367453 0.8033702
##   [52,] 1.0956982 1.9935256
##   [53,] 0.8014215 0.9792527
##   [54,] 0.9921758 1.5299392
##   [55,] 0.8015481 0.7173157
##   [56,] 1.4801733 1.0072621
##   [57,] 0.8354639 0.7273579
##   [58,] 0.8667517 0.9130729
##   [59,] 0.7139552 0.6234982
##   [60,] 0.9404633 1.3652252
##   [61,] 1.5389392 1.3311234
##   [62,] 1.3748654 1.0907847
##   [63,] 1.5662459 0.4608081
##   [64,] 1.0582882 1.9016102
##   [65,] 1.0433121 0.8891966
##   [66,] 0.8703186 0.6227471
##   [67,] 0.9221372 0.7451966
##   [68,] 1.1069671 1.0234807
##   [69,] 1.6326766 0.5705001
##   [70,] 1.0550294 1.0948635
##   [71,] 0.6443630 1.0946436
##   [72,] 1.0279973 0.7488073
##   [73,] 0.8860276 1.0289225
##   [74,] 0.6834631 1.5481228
##   [75,] 1.0123183 0.8594135
##   [76,] 0.7575223 1.0853400
##   [77,] 0.8831746 0.8116649
##   [78,] 0.6335688 1.5104526
##   [79,] 0.8994963 0.7639986
##   [80,] 0.9418337 1.0198313
##   [81,] 0.8629093 1.1039513
##   [82,] 1.0200588 1.2065980
##   [83,] 0.8144726 0.7576621
##   [84,] 0.7335115 0.8505811
##   [85,] 1.1119942 2.1721988
##   [86,] 0.8891733 1.3794132
##   [87,] 1.1187202 1.0796089
##   [88,] 0.8434273 0.8372166
##   [89,] 0.7771607 1.0826493
##   [90,] 1.0434884 0.9876460
##   [91,] 0.9610184 0.6495324
##   [92,] 1.1604486 1.0122465
##   [93,] 0.7211255 0.5230502
##   [94,] 0.8162593 1.2959449
##   [95,] 0.6563803 0.6869997
##   [96,] 1.0905837 1.5987813
##   [97,] 0.9009368 0.9023747
##   [98,] 1.0064693 0.6530865
##   [99,] 1.1966875 1.6187735
##  [100,] 1.1059363 0.5017230
##  [101,] 1.1527274 2.3372583
##  [102,] 0.7835610 0.8960291
##  [103,] 1.0464390 0.7823128
##  [104,] 0.8555713 1.0191966
##  [105,] 0.7467780 0.8197722
##  [106,] 0.9827330 1.0073471
##  [107,] 0.9225189 1.6664601
##  [108,] 0.7463250 1.1959189
##  [109,] 0.8791926 1.0803507
##  [110,] 1.1698053 0.9732803
##  [111,] 1.3225614 1.3099382
##  [112,] 0.6712121 1.1042916
##  [113,] 1.0062575 1.9974059
##  [114,] 1.0142288 1.2114912
##  [115,] 1.2024930 0.6524728
##  [116,] 1.0011702 1.4386652
##  [117,] 0.9526578 0.9273614
##  [118,] 0.9993206 0.7496141
##  [119,] 1.0081862 1.7408167
##  [120,] 0.6925698 1.0668638
##  [121,] 0.7418846 1.0229061
##  [122,] 0.9111685 0.8778469
##  [123,] 0.9389552 0.7600941
##  [124,] 1.0179296 0.4383833
##  [125,] 0.9743272 0.9563528
##  [126,] 0.6607388 0.8379641
##  [127,] 0.9070053 0.9888186
##  [128,] 1.1067524 0.5666461
##  [129,] 0.8530004 1.0434429
##  [130,] 1.9983855 0.8171583
##  [131,] 1.0846125 0.4367185
##  [132,] 1.0204049 0.8932890
##  [133,] 1.6152060 0.6155433
##  [134,] 0.8259227 0.6627932
##  [135,] 1.1571453 0.8701155
##  [136,] 0.8986680 0.6342253
##  [137,] 0.7864203 1.0042525
##  [138,] 0.8186942 2.0558123
##  [139,] 0.8700612 0.6954922
##  [140,] 0.8830093 2.2889715
##  [141,] 0.7940993 0.4858179
##  [142,] 0.9038612 0.7816724
##  [143,] 1.5575002 0.7661569
##  [144,] 0.8859882 2.2274924
##  [145,] 0.5683356 0.9388739
##  [146,] 0.9471636 0.9354018
##  [147,] 1.0748059 1.2757003
##  [148,] 0.9394405 0.6696556
##  [149,] 1.0859059 0.4341180
##  [150,] 0.8256234 0.9385925
##  [151,] 0.6879763 0.7469495
##  [152,] 0.9574550 1.2642540
##  [153,] 1.1914162 0.9132953
##  [154,] 1.3384168 0.6758206
##  [155,] 0.7777569 1.0663843
##  [156,] 0.9715582 0.6568825
##  [157,] 0.8296341 0.6476020
##  [158,] 1.1987696 0.6091003
##  [159,] 1.5730242 2.2618587
##  [160,] 0.9159695 0.7753106
##  [161,] 0.8941260 1.0382393
##  [162,] 0.6218522 0.9687740
##  [163,] 1.0943498 0.6523702
##  [164,] 1.2108910 1.1976399
##  [165,] 0.7883840 0.8194874
##  [166,] 0.9048849 0.5568673
##  [167,] 0.9042066 1.1396972
##  [168,] 0.9181192 1.5461137
##  [169,] 1.1995373 0.6652225
##  [170,] 0.9231254 2.4353733
##  [171,] 0.6711432 1.0325689
##  [172,] 1.1846882 0.9716583
##  [173,] 1.2988495 0.8867150
##  [174,] 1.7214302 0.8422312
##  [175,] 0.9026167 0.9793041
##  [176,] 0.6020726 1.2981325
##  [177,] 1.0903913 1.0440893
##  [178,] 0.9490001 1.6196099
##  [179,] 0.9790189 0.6157929
##  [180,] 0.9597741 1.1694337
##  [181,] 1.2362320 0.9332901
##  [182,] 0.6834434 1.4941938
##  [183,] 0.7852458 0.7798681
##  [184,] 1.0374391 0.6702365
##  [185,] 1.0826624 1.0300561
##  [186,] 0.9885426 1.1624639
##  [187,] 1.1698030 1.0942170
##  [188,] 1.4563440 0.8848160
##  [189,] 0.7282734 0.8601243
##  [190,] 0.7598006 0.7615347
##  [191,] 0.9487614 0.8286824
##  [192,] 0.8871561 1.4594507
##  [193,] 1.3386185 1.4256766
##  [194,] 1.0974727 1.9393584
##  [195,] 1.1096593 1.3963962
##  [196,] 0.9152296 1.1095483
##  [197,] 0.9002075 0.8789687
##  [198,] 1.1621309 1.0885066
##  [199,] 0.9964395 1.0019736
##  [200,] 0.9242959 0.5814402
##  [201,] 1.0288035 0.7377241
##  [202,] 1.1186543 0.6361712
##  [203,] 1.2759820 1.0960955
##  [204,] 0.9171855 0.4211564
##  [205,] 1.0481591 0.4240160
##  [206,] 1.1553901 1.6278168
##  [207,] 0.6222751 1.2163500
##  [208,] 1.3310533 0.7622337
##  [209,] 0.7773204 0.5643581
##  [210,] 1.1985057 1.4269892
##  [211,] 0.7730192 1.2078782
##  [212,] 1.0713579 0.5754859
##  [213,] 0.9105967 0.9139665
##  [214,] 0.8784748 1.0149813
##  [215,] 0.7734081 1.2245541
##  [216,] 1.3390346 1.0569862
##  [217,] 1.4085801 0.7713428
##  [218,] 0.9523260 0.8677492
##  [219,] 0.7113350 0.7997531
##  [220,] 0.8965105 1.0972583
##  [221,] 0.9558987 0.5857873
##  [222,] 1.0779089 1.3149371
##  [223,] 1.1449537 0.5400654
##  [224,] 0.8097177 0.5895460
##  [225,] 0.6922418 1.2811131
##  [226,] 1.1447442 1.2382836
##  [227,] 1.7188445 1.4517465
##  [228,] 0.7166206 1.6713434
##  [229,] 1.2067288 0.8114782
##  [230,] 0.8214649 0.8687518
##  [231,] 1.1033250 1.7134716
##  [232,] 0.6555597 0.7768385
##  [233,] 1.4674335 0.6443391
##  [234,] 1.5370414 1.0235137
##  [235,] 0.9053052 0.6093370
##  [236,] 1.2105707 0.5763772
##  [237,] 0.7696409 0.6243324
##  [238,] 0.9968730 0.8900137
##  [239,] 1.5413609 0.6929368
##  [240,] 0.9010437 0.7407347
##  [241,] 1.1162973 2.0268588
##  [242,] 0.9659798 0.6354707
##  [243,] 0.5902856 1.0137893
##  [244,] 0.7832564 0.8016591
##  [245,] 0.9615053 1.3787563
##  [246,] 0.7129944 1.2261138
##  [247,] 1.1387450 0.6305887
##  [248,] 0.9751861 0.8104840
##  [249,] 0.6984068 0.8319336
##  [250,] 0.6373913 0.7754380
##  [251,] 0.9022995 0.5979636
##  [252,] 1.2330304 1.8175141
##  [253,] 0.9474456 0.8187415
##  [254,] 0.9097714 1.1710634
##  [255,] 1.0335433 0.6704535
##  [256,] 1.2363497 0.9599371
##  [257,] 0.7156298 1.6807655
##  [258,] 1.1035539 0.6376208
##  [259,] 1.4691391 1.2117381
##  [260,] 1.6270890 0.7078884
##  [261,] 1.1622335 0.9348451
##  [262,] 1.2825137 0.6336806
##  [263,] 0.8898485 0.9362106
##  [264,] 0.6657424 0.4617276
##  [265,] 1.1461150 0.4539938
##  [266,] 1.1870100 0.5491625
##  [267,] 0.8315723 0.8847299
##  [268,] 0.8649513 1.1156376
##  [269,] 0.9925342 1.6996706
##  [270,] 1.4954069 0.8574538
##  [271,] 1.0151816 0.7954984
##  [272,] 0.9204992 0.5546107
##  [273,] 1.0094482 1.1378430
##  [274,] 0.9721784 1.3799164
##  [275,] 0.7905294 1.0807057
##  [276,] 1.3072698 0.7813363
##  [277,] 1.0216908 0.7025768
##  [278,] 0.6814700 0.9113849
##  [279,] 1.4877584 0.9879683
##  [280,] 0.7067873 0.6918815
##  [281,] 1.2599603 0.7665468
##  [282,] 0.8379458 0.6838818
##  [283,] 0.7629119 0.7907845
##  [284,] 0.7951402 0.4449014
##  [285,] 0.7483610 0.6457675
##  [286,] 0.8750925 1.2912976
##  [287,] 0.9799530 1.1775917
##  [288,] 0.7717398 1.5113424
##  [289,] 0.8920331 0.6638606
##  [290,] 0.8850920 1.1943201
##  [291,] 0.7054020 0.4187951
##  [292,] 1.0063468 0.9273367
##  [293,] 1.4218840 0.6826440
##  [294,] 1.2244410 0.6609222
##  [295,] 0.8876476 1.1888716
##  [296,] 0.8463507 0.8991687
##  [297,] 0.7170135 1.0256740
##  [298,] 1.1553379 1.1627284
##  [299,] 0.8123577 0.8537526
##  [300,] 1.0318169 0.9360014
##  [301,] 0.8687966 1.4737213
##  [302,] 0.5821903 1.1553037
##  [303,] 1.0272661 0.9123450
##  [304,] 0.8506397 1.8539520
##  [305,] 1.2471187 1.5538051
##  [306,] 1.4895482 0.5145355
##  [307,] 0.6922828 0.8606107
##  [308,] 1.4539256 1.1413005
##  [309,] 1.0847728 1.9068872
##  [310,] 0.8258368 1.4258448
##  [311,] 0.8883331 0.8529337
##  [312,] 0.6496136 0.6108740
##  [313,] 1.4945349 1.2535243
##  [314,] 1.0480248 1.2766606
##  [315,] 0.9747674 1.7610125
##  [316,] 1.0884410 0.5116787
##  [317,] 1.1746168 0.8010849
##  [318,] 1.3243001 0.6190285
##  [319,] 0.9065934 1.0296995
##  [320,] 1.2027073 0.9154319
##  [321,] 0.7218910 0.9206214
##  [322,] 1.3284566 0.6600597
##  [323,] 1.1336340 1.8932409
##  [324,] 1.0236268 0.9238590
##  [325,] 1.2652801 1.5107180
##  [326,] 0.9152746 0.7387059
##  [327,] 0.9672371 0.9284989
##  [328,] 0.7316927 1.9568907
##  [329,] 0.8797650 1.0778482
##  [330,] 0.9178737 0.7014556
##  [331,] 0.9152060 0.8136149
##  [332,] 0.8999037 0.7183545
##  [333,] 1.5449566 0.9601439
##  [334,] 1.3106149 0.9611556
##  [335,] 1.0859448 1.7934081
##  [336,] 1.2136144 0.8918141
##  [337,] 0.9492314 2.2266242
##  [338,] 0.8140561 0.4081924
##  [339,] 0.8587168 1.1558532
##  [340,] 1.0384943 1.6385514
##  [341,] 0.8114522 0.6400705
##  [342,] 0.7965935 0.8016356
##  [343,] 1.6729497 0.9487999
##  [344,] 1.3747821 1.7914345
##  [345,] 0.9207881 1.0358809
##  [346,] 0.8409237 0.8957892
##  [347,] 0.9744638 0.6645217
##  [348,] 0.6087027 1.1666663
##  [349,] 1.0213767 0.6366218
##  [350,] 1.2700673 0.7857432
##  [351,] 0.9886025 0.7056940
##  [352,] 0.8375481 1.8406823
##  [353,] 1.0552406 0.8655581
##  [354,] 1.4592248 1.1846736
##  [355,] 0.7559136 1.6020718
##  [356,] 1.3367922 1.3379455
##  [357,] 0.8523767 0.8153939
##  [358,] 0.7104563 0.6798510
##  [359,] 1.2930890 0.7878119
##  [360,] 1.0361189 1.8717683
##  [361,] 0.7832355 1.5151118
##  [362,] 0.9481338 0.9338039
##  [363,] 1.4519576 0.8028800
##  [364,] 1.0474750 1.0526999
##  [365,] 1.1872180 1.1270395
##  [366,] 0.9588807 1.3884066
##  [367,] 1.1845218 1.0021921
##  [368,] 1.1611628 0.7151781
##  [369,] 0.8741799 0.7142983
##  [370,] 0.8748083 0.5851268
##  [371,] 0.6618818 0.7817139
##  [372,] 1.0319797 0.9124246
##  [373,] 0.8829408 1.1531118
##  [374,] 0.7873873 1.4522934
##  [375,] 1.1170010 1.3825472
##  [376,] 1.1915700 1.6553802
##  [377,] 0.8499005 1.1526795
##  [378,] 1.0971854 0.9573359
##  [379,] 0.8528670 0.6432957
##  [380,] 0.9882874 0.5983281
##  [381,] 1.0402289 1.1817608
##  [382,] 0.8794137 1.7558352
##  [383,] 0.7195975 0.7156942
##  [384,] 1.4192541 0.7076310
##  [385,] 1.4536291 1.1565796
##  [386,] 0.6599376 0.6222323
##  [387,] 1.0613673 0.9209780
##  [388,] 0.6851955 2.4240576
##  [389,] 0.8637733 0.7583789
##  [390,] 0.6623758 0.9910694
##  [391,] 0.7525030 0.6349519
##  [392,] 0.9805384 1.3532980
##  [393,] 0.8079229 0.9840777
##  [394,] 1.1647824 1.0483914
##  [395,] 0.7194946 0.7072098
##  [396,] 1.3349356 0.8436812
##  [397,] 1.1541774 1.0812671
##  [398,] 0.8342114 0.6936785
##  [399,] 0.7038471 1.0969281
##  [400,] 1.8898549 1.0182010
##  [401,] 0.9256818 1.3323629
##  [402,] 1.1786843 1.5859867
##  [403,] 0.9436439 1.3906072
##  [404,] 1.2569670 1.0803403
##  [405,] 0.9950784 0.4936131
##  [406,] 0.7311659 1.1292875
##  [407,] 1.3747476 1.0411726
##  [408,] 0.8184992 1.3209938
##  [409,] 1.0949515 0.8877038
##  [410,] 1.0569895 1.0340819
##  [411,] 1.1757795 0.8519082
##  [412,] 0.8142715 0.6303600
##  [413,] 0.8721808 0.7768189
##  [414,] 0.9317106 1.2919676
##  [415,] 0.6683992 0.7827722
##  [416,] 1.0373923 0.9132812
##  [417,] 1.2042494 0.6388894
##  [418,] 1.6471126 2.2971171
##  [419,] 0.8849845 0.9326764
##  [420,] 0.7470641 1.2317629
##  [421,] 1.0556645 0.6568333
##  [422,] 0.8417463 0.7609128
##  [423,] 1.4108212 1.5622206
##  [424,] 1.3105663 0.6391992
##  [425,] 1.4098391 0.6010667
##  [426,] 0.9861760 1.3185976
##  [427,] 0.8849698 0.6997390
##  [428,] 0.9105397 1.0111862
##  [429,] 1.0080899 2.0868239
##  [430,] 0.9419721 0.4771614
##  [431,] 0.9851730 0.6056651
##  [432,] 1.2505409 1.0327616
##  [433,] 1.1680824 0.8479458
##  [434,] 0.9185791 1.3887396
##  [435,] 1.0900820 1.0626066
##  [436,] 0.7907061 0.9410099
##  [437,] 1.0291240 1.7763959
##  [438,] 0.9351521 1.4039435
##  [439,] 1.0115685 0.7202455
##  [440,] 0.7893051 1.3861346
##  [441,] 0.7540565 0.6243735
##  [442,] 1.0458756 1.1328562
##  [443,] 1.0075516 1.1768702
##  [444,] 0.7956236 1.4199946
##  [445,] 1.0304512 0.7007461
##  [446,] 1.0416461 0.9313388
##  [447,] 1.1759730 1.5966968
##  [448,] 0.8095818 0.9618909
##  [449,] 0.9578445 0.6286166
##  [450,] 0.7184615 0.9509667
##  [451,] 0.7880663 1.4277396
##  [452,] 0.7462401 1.0611978
##  [453,] 1.0072953 1.6602300
##  [454,] 1.2385436 1.0336626
##  [455,] 1.0422985 1.1948928
##  [456,] 1.0666408 0.6744977
##  [457,] 1.2723473 1.0320136
##  [458,] 1.4003171 0.6960419
##  [459,] 0.9279368 0.6034164
##  [460,] 0.6523342 1.1381759
##  [461,] 0.9938707 0.9219967
##  [462,] 1.0408563 0.6955700
##  [463,] 0.9983313 1.4186865
##  [464,] 0.7687494 0.8203028
##  [465,] 1.1979364 0.7974070
##  [466,] 1.0891462 1.3793971
##  [467,] 1.1864250 0.7954614
##  [468,] 1.5319737 1.3542882
##  [469,] 1.0499166 0.9100716
##  [470,] 0.7716326 1.2938437
##  [471,] 1.3827901 0.4946325
##  [472,] 1.1432124 0.5476824
##  [473,] 1.0088276 1.3100302
##  [474,] 0.7136855 0.9051968
##  [475,] 0.9243660 1.0874738
##  [476,] 1.0204218 0.7362711
##  [477,] 1.2141742 1.7717525
##  [478,] 0.7995829 1.0141914
##  [479,] 0.7228142 0.9711080
##  [480,] 0.7979670 1.1802573
##  [481,] 0.9148292 0.9082244
##  [482,] 1.2035875 2.1965848
##  [483,] 0.8699438 0.9125173
##  [484,] 0.6529808 1.2048400
##  [485,] 0.9413549 0.7660134
##  [486,] 1.0475489 1.4349146
##  [487,] 0.7567694 1.7538804
##  [488,] 0.8378985 1.0160409
##  [489,] 1.1122056 1.2266632
##  [490,] 0.7807953 0.9998291
##  [491,] 1.0181109 1.6788276
##  [492,] 1.3337889 1.5436170
##  [493,] 1.0735679 1.2009316
##  [494,] 1.0002318 0.5478365
##  [495,] 0.6628102 1.2608433
##  [496,] 1.4138407 0.7345840
##  [497,] 1.3595857 0.6474643
##  [498,] 1.4373937 1.0054408
##  [499,] 1.2742705 1.1056105
##  [500,] 0.6923206 0.9871644
##  [501,] 0.8362445 1.2278130
##  [502,] 0.9995605 0.7531809
##  [503,] 1.2484888 1.1836446
##  [504,] 0.7987944 1.0280753
##  [505,] 1.1865219 1.2454727
##  [506,] 1.1263705 1.0789556
##  [507,] 0.7722824 0.8628228
##  [508,] 1.1050887 0.7522838
##  [509,] 0.8310487 0.5049221
##  [510,] 1.0801598 1.0883024
##  [511,] 0.9162521 0.9049726
##  [512,] 1.1362567 0.9350786
##  [513,] 0.9994049 1.4652746
##  [514,] 1.0099219 1.0595399
##  [515,] 0.7563495 0.9100463
##  [516,] 0.9597159 0.7044851
##  [517,] 1.6361470 0.9701807
##  [518,] 1.0661419 1.0830898
##  [519,] 0.9601228 1.6245887
##  [520,] 0.8625848 0.8867070
##  [521,] 0.7940096 0.6980229
##  [522,] 1.0601210 1.2260177
##  [523,] 0.9777728 2.0722384
##  [524,] 0.6639637 1.3204214
##  [525,] 1.0375763 1.8108397
##  [526,] 0.8046238 0.4696782
##  [527,] 0.8583042 0.7425944
##  [528,] 1.0171160 0.7090378
##  [529,] 0.9432124 0.9115497
##  [530,] 1.0412637 1.7703092
##  [531,] 1.1117888 0.6163552
##  [532,] 0.6763223 1.1610420
##  [533,] 1.0172353 0.8148531
##  [534,] 0.9461504 0.9832690
##  [535,] 0.9448430 2.5372305
##  [536,] 1.0617676 0.7525207
##  [537,] 0.9874533 1.2917943
##  [538,] 1.3938811 0.7762924
##  [539,] 1.3713137 0.5570258
##  [540,] 0.7309617 0.7992088
##  [541,] 0.5689095 1.2545645
##  [542,] 1.2700155 0.8753659
##  [543,] 0.7717904 2.1850559
##  [544,] 1.1114021 0.6659290
##  [545,] 0.8538241 0.7660279
##  [546,] 1.0774117 0.8879141
##  [547,] 1.7413535 1.3403055
##  [548,] 0.8818999 0.7706357
##  [549,] 0.6491464 0.8462882
##  [550,] 1.0300334 0.9020074
##  [551,] 0.9633985 1.4050567
##  [552,] 0.9452430 1.2013780
##  [553,] 0.8512696 0.7622152
##  [554,] 0.7805467 0.6974497
##  [555,] 0.8425127 1.3400283
##  [556,] 0.8257424 0.6445243
##  [557,] 0.8605421 0.6821917
##  [558,] 0.9691283 1.3745744
##  [559,] 1.0509504 1.5523621
##  [560,] 0.6566268 1.0089291
##  [561,] 0.6510395 0.7121949
##  [562,] 0.7373723 0.5667356
##  [563,] 1.0914281 0.6311599
##  [564,] 0.8708800 0.7225282
##  [565,] 1.3356066 0.8150690
##  [566,] 1.2094198 0.8573007
##  [567,] 1.1740845 0.5577471
##  [568,] 0.9508899 0.5490536
##  [569,] 1.1283067 0.6694143
##  [570,] 1.1129599 1.4479440
##  [571,] 1.0907502 0.5604433
##  [572,] 0.9310354 2.5463177
##  [573,] 0.7128368 0.8583207
##  [574,] 0.9149813 0.6932366
##  [575,] 0.9818987 1.1499053
##  [576,] 1.3918538 1.1038226
##  [577,] 0.8127028 0.5388369
##  [578,] 0.9374799 1.1256454
##  [579,] 1.5102201 1.2884156
##  [580,] 0.9285806 0.6344021
##  [581,] 0.9788473 0.6728797
##  [582,] 1.5724899 1.0182164
##  [583,] 1.1019201 2.5787719
##  [584,] 0.9102513 1.3376320
##  [585,] 0.8112455 0.8751645
##  [586,] 0.6116901 0.7744283
##  [587,] 1.1279668 0.6916508
##  [588,] 0.7902016 1.1291787
##  [589,] 0.9659878 0.9814856
##  [590,] 1.2265509 0.7915500
##  [591,] 1.1608574 0.8252677
##  [592,] 0.8098571 1.1096348
##  [593,] 0.8451276 1.4780823
##  [594,] 0.7145211 0.8165101
##  [595,] 0.7522700 1.2191574
##  [596,] 1.1508224 0.7309342
##  [597,] 1.0463537 0.4314109
##  [598,] 0.6606856 1.0267772
##  [599,] 0.7281761 1.6643526
##  [600,] 0.9441797 1.1878526
##  [601,] 1.0210815 0.9135756
##  [602,] 0.8853497 0.9080742
##  [603,] 1.2601296 1.1384046
##  [604,] 0.8913464 1.8958012
##  [605,] 1.1838314 1.3561961
##  [606,] 1.0454845 1.0771377
##  [607,] 0.7076734 0.5558876
##  [608,] 1.1911574 0.9053671
##  [609,] 0.9097440 0.7427913
##  [610,] 0.9140538 0.8269670
##  [611,] 0.9805835 0.8575633
##  [612,] 0.8377397 1.2681338
##  [613,] 0.7648666 0.6949336
##  [614,] 0.8015448 0.6697193
##  [615,] 0.8482027 0.9620422
##  [616,] 0.9586343 0.8103749
##  [617,] 0.9610486 0.6357496
##  [618,] 1.0817820 0.8920122
##  [619,] 1.0315467 1.2252929
##  [620,] 0.6753093 0.7820951
##  [621,] 1.4796468 0.6529061
##  [622,] 1.0647226 0.8328238
##  [623,] 1.0742636 1.2280341
##  [624,] 0.7951198 0.7042203
##  [625,] 0.9896587 0.8320357
##  [626,] 1.2267878 0.9810308
##  [627,] 0.8940249 1.5533450
##  [628,] 0.9945326 0.9146025
##  [629,] 1.0004500 0.7136548
##  [630,] 1.2948210 0.9139342
##  [631,] 0.8820382 2.1836113
##  [632,] 1.0197589 0.8425456
##  [633,] 1.2051231 0.9581435
##  [634,] 1.3171978 0.9098750
##  [635,] 1.0773743 0.8164991
##  [636,] 0.9655231 1.1561200
##  [637,] 0.9461901 0.6545158
##  [638,] 0.7004667 0.5051048
##  [639,] 1.1171765 0.8711887
##  [640,] 1.1726109 0.8157079
##  [641,] 1.0741742 1.5360924
##  [642,] 0.8524881 0.8929382
##  [643,] 0.8756135 0.5001778
##  [644,] 0.6675249 0.9709041
##  [645,] 1.2241454 1.1482182
##  [646,] 0.8112391 0.8112064
##  [647,] 1.2250176 0.9350450
##  [648,] 1.0686728 1.5057354
##  [649,] 1.1320992 1.2598088
##  [650,] 1.0007441 1.0756824
##  [651,] 1.1406389 1.0617333
##  [652,] 0.9435898 1.0388970
##  [653,] 1.1642139 0.8305710
##  [654,] 1.2205179 0.7695437
##  [655,] 1.0576756 0.6167439
##  [656,] 1.2478043 0.5952418
##  [657,] 1.1376000 0.4356292
##  [658,] 0.8395600 0.6750347
##  [659,] 0.8545934 0.9860745
##  [660,] 1.2533916 0.5792490
##  [661,] 0.9667124 1.5657977
##  [662,] 1.3460880 1.5281814
##  [663,] 0.8926399 0.7658495
##  [664,] 0.8415887 0.4549130
##  [665,] 0.8907911 0.8003692
##  [666,] 1.0984201 0.7376925
##  [667,] 1.0478200 1.1647473
##  [668,] 1.1510552 0.5201870
##  [669,] 0.8429607 1.1449389
##  [670,] 1.1504978 1.2745196
##  [671,] 1.1249913 1.5244717
##  [672,] 0.9000975 0.8966002
##  [673,] 1.2177991 1.0861539
##  [674,] 0.8350510 0.7724448
##  [675,] 1.5771828 0.8203667
##  [676,] 1.1233469 1.5203297
##  [677,] 0.8927191 0.6858801
##  [678,] 0.6546022 0.6494287
##  [679,] 0.7095850 1.3426426
##  [680,] 0.7339797 0.9288247
##  [681,] 1.1153213 0.8035202
##  [682,] 0.7063514 1.3179892
##  [683,] 0.9515680 1.1928104
##  [684,] 0.9810378 1.6913492
##  [685,] 1.0907386 1.0056699
##  [686,] 1.3081349 0.7553860
##  [687,] 0.9105737 0.6629750
##  [688,] 0.8836618 1.0580228
##  [689,] 0.9571601 0.7914128
##  [690,] 0.8281024 0.6381703
##  [691,] 1.0815391 0.7579322
##  [692,] 0.7021736 0.9335748
##  [693,] 1.9495926 1.1939827
##  [694,] 1.0335967 0.8876083
##  [695,] 0.8710294 1.1775079
##  [696,] 0.7291199 2.2787091
##  [697,] 0.8773754 1.2528333
##  [698,] 1.0599969 0.9090698
##  [699,] 0.9425400 0.5811418
##  [700,] 0.6226369 0.9772272
##  [701,] 1.0336737 0.9985077
##  [702,] 1.2102720 0.7138341
##  [703,] 0.8343905 0.8804909
##  [704,] 0.5187323 1.4726165
##  [705,] 0.7456669 0.9985487
##  [706,] 1.1689312 0.9124786
##  [707,] 1.3297981 1.0665392
##  [708,] 1.0936008 0.9450305
##  [709,] 1.0212678 0.6897838
##  [710,] 1.1186269 0.6897348
##  [711,] 1.2434570 0.6601420
##  [712,] 0.6839162 0.7540220
##  [713,] 0.7923212 0.6121316
##  [714,] 0.8210173 1.1850369
##  [715,] 0.8760243 0.8939205
##  [716,] 0.8668695 0.8474117
##  [717,] 0.9228878 1.3896717
##  [718,] 1.0780223 0.7851917
##  [719,] 1.0618084 0.4667396
##  [720,] 1.1515969 1.5316238
##  [721,] 0.8188895 0.7682168
##  [722,] 1.0117200 0.8563818
##  [723,] 0.6449391 1.2130487
##  [724,] 0.5481431 0.6863139
##  [725,] 0.9117985 0.9866853
##  [726,] 0.8869320 1.5445260
##  [727,] 0.9311288 0.4447642
##  [728,] 1.4588945 0.9686408
##  [729,] 0.6927355 1.1138203
##  [730,] 1.1763444 0.7607979
##  [731,] 0.6332406 1.7742458
##  [732,] 0.7111849 1.0165224
##  [733,] 0.7398302 0.5346108
##  [734,] 0.8434959 0.7269503
##  [735,] 0.8644000 1.1165930
##  [736,] 1.3608300 0.7534230
##  [737,] 1.3590513 0.7145083
##  [738,] 1.1583086 0.8343179
##  [739,] 1.0357161 0.4491441
##  [740,] 1.0908996 0.7275749
##  [741,] 0.8868028 0.8261360
##  [742,] 0.7968812 0.9471389
##  [743,] 1.1775799 0.8621462
##  [744,] 0.6190517 1.3619013
##  [745,] 1.1039108 1.8537294
##  [746,] 1.3417730 0.9945346
##  [747,] 0.7281150 0.5276156
##  [748,] 1.2165625 0.7998950
##  [749,] 0.9104462 0.6459175
##  [750,] 0.8727630 0.9148148
##  [751,] 0.7974233 0.7056701
##  [752,] 1.3568454 1.4310807
##  [753,] 0.9875426 0.7619403
##  [754,] 0.8564073 0.6071100
##  [755,] 1.0653156 0.8158978
##  [756,] 0.7144009 1.1447027
##  [757,] 1.1330653 0.7513918
##  [758,] 0.7292477 0.4458524
##  [759,] 0.8844969 0.9061465
##  [760,] 1.5017314 1.1801458
##  [761,] 0.7284627 1.0100454
##  [762,] 0.8088696 0.4707234
##  [763,] 1.2644642 0.8062961
##  [764,] 0.9980485 0.5955539
##  [765,] 0.9795589 0.5678477
##  [766,] 0.6830172 1.7636645
##  [767,] 0.9496594 0.9216360
##  [768,] 1.2373661 1.4231791
##  [769,] 1.2068819 0.4874635
##  [770,] 1.1667195 1.1642790
##  [771,] 0.8345058 2.0890002
##  [772,] 1.1296624 0.9052363
##  [773,] 0.9063465 0.9165163
##  [774,] 0.9366595 1.1301713
##  [775,] 1.1108126 1.7173249
##  [776,] 1.5037515 0.6503625
##  [777,] 0.8549352 0.5787142
##  [778,] 0.7910514 0.5160091
##  [779,] 0.9270861 0.4971850
##  [780,] 1.3921682 0.9393010
##  [781,] 1.1776675 0.7976546
##  [782,] 1.1254297 0.7985075
##  [783,] 1.2700323 0.7516965
##  [784,] 0.9952413 1.0457646
##  [785,] 1.8776881 1.0403365
##  [786,] 1.6652513 0.6693687
##  [787,] 1.4564181 1.5399808
##  [788,] 1.0518238 1.0179514
##  [789,] 0.8910326 0.8224263
##  [790,] 0.7234327 0.9381834
##  [791,] 1.0354348 0.8088409
##  [792,] 0.7831335 1.2080390
##  [793,] 0.7779109 0.5269874
##  [794,] 1.2358951 1.1025438
##  [795,] 1.3698230 0.9328627
##  [796,] 0.7625550 0.8996189
##  [797,] 1.2230280 0.7803857
##  [798,] 1.0799620 0.5194838
##  [799,] 1.1175711 0.7418914
##  [800,] 0.7430377 0.5449773
##  [801,] 1.3688720 0.4726213
##  [802,] 0.7100076 0.9781957
##  [803,] 1.3863096 0.7276492
##  [804,] 1.0541848 0.6134654
##  [805,] 0.6466196 1.4715015
##  [806,] 1.2352113 0.9951791
##  [807,] 0.8185568 0.8084129
##  [808,] 0.9073499 1.5620875
##  [809,] 1.1805854 0.9690735
##  [810,] 1.8905646 1.5984799
##  [811,] 0.8559201 0.9265086
##  [812,] 1.0982650 0.6809430
##  [813,] 1.0820116 0.6690977
##  [814,] 0.8344484 0.6337329
##  [815,] 1.1582834 0.8944639
##  [816,] 1.1179986 0.5245896
##  [817,] 0.7709058 1.4126450
##  [818,] 0.9422691 2.2582088
##  [819,] 0.7537581 1.3296694
##  [820,] 1.4933589 0.6404407
##  [821,] 0.7276851 0.9720522
##  [822,] 1.1625574 0.6145817
##  [823,] 1.1935869 1.0097396
##  [824,] 1.0938354 1.2159592
##  [825,] 0.9405661 0.7327151
##  [826,] 1.0086534 0.4810494
##  [827,] 0.7416345 2.1215002
##  [828,] 1.1297856 0.8358801
##  [829,] 1.1608361 1.4600939
##  [830,] 0.8437548 1.2005421
##  [831,] 1.2568503 0.6224805
##  [832,] 0.8881253 1.2352441
##  [833,] 1.5038064 0.7481373
##  [834,] 1.3328276 0.7861741
##  [835,] 0.8366555 1.3530752
##  [836,] 0.7311089 1.0337387
##  [837,] 0.8410796 1.3279566
##  [838,] 1.1176104 1.0785941
##  [839,] 0.9105366 0.9498887
##  [840,] 1.1787451 1.0222640
##  [841,] 1.1318502 0.7583291
##  [842,] 0.9578590 0.9130691
##  [843,] 0.9995401 0.5880856
##  [844,] 0.9442281 1.5054718
##  [845,] 1.1233201 0.9753318
##  [846,] 0.8272991 1.5006357
##  [847,] 1.0030089 1.5779782
##  [848,] 0.8730270 0.9750119
##  [849,] 0.8802457 0.7532562
##  [850,] 0.9710219 1.1733542
##  [851,] 0.8186101 2.0033247
##  [852,] 1.0052238 1.0744092
##  [853,] 0.8234603 1.3492680
##  [854,] 0.7653775 0.9757207
##  [855,] 0.7100096 0.8891431
##  [856,] 1.0240277 0.9251579
##  [857,] 0.7278763 0.7648795
##  [858,] 1.2471697 0.8534846
##  [859,] 0.8580268 0.6730740
##  [860,] 0.7419584 0.6245537
##  [861,] 1.1125976 0.9494930
##  [862,] 0.8169600 0.4943412
##  [863,] 0.8410116 1.2008882
##  [864,] 1.3524158 1.2142347
##  [865,] 0.9270828 0.7588045
##  [866,] 1.2727243 0.9287057
##  [867,] 1.0634273 1.3315715
##  [868,] 1.2908437 0.9649245
##  [869,] 0.8361501 1.3533880
##  [870,] 0.8270655 0.9583979
##  [871,] 0.7538738 0.6881017
##  [872,] 0.8064603 1.2180530
##  [873,] 1.2115983 0.9045953
##  [874,] 0.7120511 0.8785017
##  [875,] 1.1700805 0.6949821
##  [876,] 0.8085220 1.0024204
##  [877,] 0.8455653 0.8946572
##  [878,] 0.7300721 1.1151274
##  [879,] 1.3134896 1.1014955
##  [880,] 0.8545837 0.4373856
##  [881,] 1.1632470 1.0426691
##  [882,] 0.9098051 0.7189708
##  [883,] 0.7909294 0.6701250
##  [884,] 0.6996802 0.7104198
##  [885,] 1.3996799 0.8586770
##  [886,] 0.7808810 1.7370675
##  [887,] 1.1547602 0.5501348
##  [888,] 1.4305732 0.6642267
##  [889,] 0.8303718 0.9685393
##  [890,] 1.7725318 0.6676826
##  [891,] 1.1834795 1.4142568
##  [892,] 0.9418861 0.9991520
##  [893,] 1.0274995 1.1208981
##  [894,] 1.2335704 1.1857170
##  [895,] 1.1316087 0.6350304
##  [896,] 0.7524651 0.5322991
##  [897,] 1.1246407 0.6496070
##  [898,] 1.2573138 0.7944675
##  [899,] 1.2392281 1.1634965
##  [900,] 0.9376306 1.0384022
##  [901,] 0.8470956 0.6566839
##  [902,] 1.1195716 0.7496935
##  [903,] 1.3853635 0.8799549
##  [904,] 0.7440706 1.1483284
##  [905,] 0.9036580 0.7325772
##  [906,] 0.7381363 0.8320671
##  [907,] 0.8293354 1.0664001
##  [908,] 1.0539921 0.9232268
##  [909,] 0.6853733 0.9101321
##  [910,] 0.8184559 1.2846420
##  [911,] 0.9029402 1.1753026
##  [912,] 0.9701684 0.6431344
##  [913,] 1.1263137 1.2777073
##  [914,] 0.8088482 1.0758623
##  [915,] 0.7293922 1.2585453
##  [916,] 0.9071960 0.8404702
##  [917,] 1.0078934 0.8204210
##  [918,] 0.7310018 0.8641385
##  [919,] 0.7951607 0.7225296
##  [920,] 1.1561432 1.2909321
##  [921,] 0.7226826 0.5175316
##  [922,] 1.1931197 0.6093841
##  [923,] 0.8299326 1.1901180
##  [924,] 0.8434356 0.7953707
##  [925,] 0.9742587 1.4670277
##  [926,] 0.7824456 0.7943229
##  [927,] 0.8863370 1.3075809
##  [928,] 0.9241887 1.7476319
##  [929,] 1.1234405 1.3021544
##  [930,] 1.0312207 2.7008965
##  [931,] 0.9776959 0.8689248
##  [932,] 0.9159848 0.6073200
##  [933,] 0.7741412 0.7226714
##  [934,] 1.2195099 0.7570086
##  [935,] 0.7030283 0.7702797
##  [936,] 1.4377674 0.7519915
##  [937,] 0.9812586 1.0170933
##  [938,] 0.6877484 0.8056000
##  [939,] 0.7176533 0.5984473
##  [940,] 0.9580263 0.7976579
##  [941,] 1.0976956 1.2631620
##  [942,] 0.9344870 1.8505909
##  [943,] 1.3264145 1.2542971
##  [944,] 0.8825529 0.8778724
##  [945,] 0.7613343 0.6235967
##  [946,] 1.1323275 1.0396185
##  [947,] 1.0005467 1.0861274
##  [948,] 1.0660179 0.5205723
##  [949,] 0.6966505 0.9240259
##  [950,] 0.7717004 1.0892634
##  [951,] 0.8742575 0.8751287
##  [952,] 0.9468366 1.8945946
##  [953,] 1.0963024 1.1486450
##  [954,] 0.9796689 0.8958403
##  [955,] 0.8661752 0.6520644
##  [956,] 0.8420930 1.2880668
##  [957,] 0.7531119 0.6792300
##  [958,] 0.9625827 0.7059935
##  [959,] 1.0704828 0.8205543
##  [960,] 0.9481144 1.2297699
##  [961,] 1.0737924 0.6932554
##  [962,] 1.2275028 0.7635365
##  [963,] 0.9630360 0.8497115
##  [964,] 0.8327643 0.9121912
##  [965,] 0.8580259 0.9572004
##  [966,] 1.1466367 0.9815288
##  [967,] 1.0393542 0.8578388
##  [968,] 0.9512702 0.8577427
##  [969,] 1.0488519 1.0961883
##  [970,] 0.6348701 0.7183748
##  [971,] 0.9609393 1.1040752
##  [972,] 0.7922519 2.3932845
##  [973,] 1.1873477 0.6774855
##  [974,] 0.9589916 0.4638493
##  [975,] 0.9299596 1.7023602
##  [976,] 1.2677694 0.7245042
##  [977,] 0.7425041 0.7727926
##  [978,] 1.1686968 0.9013476
##  [979,] 0.8698159 1.7379282
##  [980,] 1.0122448 0.7386093
##  [981,] 0.7984454 1.0246165
##  [982,] 1.0720863 0.5371643
##  [983,] 0.7509072 0.8942217
##  [984,] 0.7744115 1.6821211
##  [985,] 1.1065803 1.0315849
##  [986,] 0.8009074 0.3220931
##  [987,] 0.9270636 0.7814048
##  [988,] 0.8529788 0.7747201
##  [989,] 1.1730860 1.8904113
##  [990,] 1.0142928 0.7631122
##  [991,] 1.3706429 1.0486103
##  [992,] 0.9381345 0.9797456
##  [993,] 0.9318007 0.7000413
##  [994,] 0.8762722 2.5656050
##  [995,] 0.9776088 1.2090579
##  [996,] 1.0423739 1.4271457
##  [997,] 1.0085656 0.6580255
##  [998,] 0.9738659 0.5063352
##  [999,] 0.7742252 0.4570135
## 
## $model.matrix
##     (Intercept) format_ITS_L6_AA$Group11 format_ITS_L6_AA$Group12
## 1             1                       -1                       -1
## 2             1                        1                        0
## 3             1                        0                        0
## 4             1                        0                        1
## 5             1                       -1                       -1
## 6             1                        1                        0
## 7             1                        0                        0
## 8             1                        0                        1
## 9             1                       -1                       -1
## 10            1                        1                        0
## 11            1                        0                        0
## 12            1                        0                        1
## 13            1                       -1                       -1
## 14            1                        1                        0
## 15            1                        0                        0
## 16            1                        0                        1
## 17            1                       -1                       -1
## 18            1                        1                        0
## 19            1                        0                        0
## 20            1                        0                        1
## 21            1                       -1                       -1
## 22            1                        1                        0
## 23            1                        0                        0
## 24            1                        0                        1
## 25            1                       -1                       -1
## 26            1                        1                        0
## 27            1                        0                        0
## 28            1                        0                        1
## 29            1                       -1                       -1
## 30            1                        1                        0
## 31            1                        0                        0
## 32            1                        0                        1
## 33            1                       -1                       -1
## 34            1                        1                        0
## 35            1                        0                        0
## 36            1                        0                        1
## 37            1                       -1                       -1
## 38            1                        1                        0
## 39            1                        0                        0
## 40            1                        0                        1
## 41            1                       -1                       -1
## 42            1                        1                        0
## 43            1                        0                        0
## 44            1                        0                        1
## 45            1                       -1                       -1
## 46            1                        1                        0
## 47            1                        0                        0
## 48            1                        0                        1
## 49            1                       -1                       -1
## 50            1                        1                        0
## 51            1                        0                        0
## 52            1                        0                        1
## 53            1                       -1                       -1
## 54            1                        1                        0
## 55            1                        0                        0
## 56            1                        0                        1
## 57            1                       -1                       -1
## 58            1                        1                        0
## 59            1                        0                        0
## 60            1                        0                        1
## 61            1                       -1                       -1
## 62            1                        1                        0
## 63            1                        0                        0
## 64            1                        0                        1
## 65            1                       -1                       -1
## 66            1                        1                        0
## 67            1                        0                        0
## 68            1                        0                        1
## 69            1                       -1                       -1
## 70            1                        1                        0
## 71            1                        0                        0
## 72            1                        0                        1
## 73            1                       -1                       -1
## 74            1                        1                        0
## 75            1                        0                        0
## 76            1                        0                        1
## 77            1                       -1                       -1
## 78            1                        1                        0
## 79            1                        0                        0
## 80            1                        0                        1
## 81            1                       -1                       -1
## 82            1                        1                        0
## 83            1                        0                        0
## 84            1                        0                        1
## 85            1                       -1                       -1
## 86            1                        1                        0
## 87            1                        0                        0
## 88            1                        0                        1
## 89            1                       -1                       -1
## 90            1                        1                        0
## 91            1                        0                        0
## 92            1                        0                        1
## 93            1                       -1                       -1
## 94            1                        1                        0
## 95            1                        0                        0
## 96            1                        0                        1
## 97            1                       -1                       -1
## 98            1                        1                        0
## 99            1                        0                        0
## 100           1                        0                        1
## 101           1                       -1                       -1
## 102           1                        1                        0
## 103           1                        0                        0
## 104           1                        0                        1
## 105           1                       -1                       -1
## 106           1                        1                        0
## 107           1                        0                        0
## 108           1                        0                        1
## 109           1                       -1                       -1
## 110           1                        1                        0
## 111           1                        0                        0
## 112           1                        0                        1
## 113           1                       -1                       -1
## 114           1                        1                        0
## 115           1                        0                        0
## 116           1                        0                        1
## 117           1                       -1                       -1
## 118           1                        1                        0
## 119           1                        0                        0
## 120           1                        0                        1
## 121           1                       -1                       -1
## 122           1                        1                        0
## 123           1                        0                        0
## 124           1                        0                        1
## 125           1                       -1                       -1
## 126           1                        1                        0
## 127           1                        0                        0
## 128           1                        0                        1
## 129           1                       -1                       -1
## 130           1                        1                        0
## 131           1                        0                        0
## 132           1                        0                        1
## 133           1                       -1                       -1
## 134           1                        1                        0
## 135           1                        0                        0
## 136           1                        0                        1
## 137           1                       -1                       -1
## 138           1                        1                        0
## 139           1                        0                        0
## 140           1                        0                        1
## 141           1                       -1                       -1
## 142           1                        1                        0
## 143           1                        0                        0
## 144           1                        0                        1
## 145           1                       -1                       -1
## 146           1                        1                        0
## 147           1                        0                        0
## 148           1                        0                        1
## 149           1                       -1                       -1
## 150           1                        1                        0
## 151           1                        0                        0
## 152           1                        0                        1
## 153           1                       -1                       -1
## 154           1                        1                        0
## 155           1                        0                        0
## 156           1                        0                        1
## 157           1                       -1                       -1
## 158           1                        1                        0
## 159           1                        0                        0
## 160           1                        0                        1
## 161           1                       -1                       -1
## 162           1                        1                        0
## 163           1                        0                        0
## 164           1                        0                        1
## 165           1                       -1                       -1
## 166           1                        1                        0
## 167           1                        0                        0
## 168           1                        0                        1
## 169           1                       -1                       -1
## 170           1                        1                        0
## 171           1                        0                        0
## 172           1                        0                        1
## 173           1                       -1                       -1
## 174           1                        1                        0
## 175           1                        0                        0
## 176           1                        0                        1
## 177           1                       -1                       -1
## 178           1                        1                        0
## 179           1                        0                        0
## 180           1                        0                        1
## 181           1                       -1                       -1
## 182           1                        1                        0
## 183           1                        0                        0
## 184           1                        0                        1
## 185           1                       -1                       -1
## 186           1                        1                        0
## 187           1                        0                        0
## 188           1                        0                        1
## 189           1                       -1                       -1
## 190           1                        1                        0
## 191           1                        0                        0
## 192           1                        0                        1
## 193           1                       -1                       -1
## 194           1                        1                        0
## 195           1                        0                        0
## 196           1                        0                        1
## 197           1                       -1                       -1
## 198           1                        1                        0
## 199           1                        0                        0
## 200           1                        0                        1
## 201           1                       -1                       -1
## 202           1                        1                        0
## 203           1                        0                        0
## 204           1                        0                        1
## 205           1                       -1                       -1
## 206           1                        1                        0
## 207           1                        0                        0
## 208           1                        0                        1
## 209           1                       -1                       -1
## 210           1                        1                        0
## 211           1                        0                        0
## 212           1                        0                        1
## 213           1                       -1                       -1
## 214           1                        1                        0
## 215           1                        0                        0
## 216           1                        0                        1
## 217           1                       -1                       -1
## 218           1                        1                        0
## 219           1                        0                        0
## 220           1                        0                        1
## 221           1                       -1                       -1
## 222           1                        1                        0
## 223           1                        0                        0
## 224           1                        0                        1
## 225           1                       -1                       -1
## 226           1                        1                        0
## 227           1                        0                        0
## 228           1                        0                        1
## 229           1                       -1                       -1
## 230           1                        1                        0
## 231           1                        0                        0
## 232           1                        0                        1
## 233           1                       -1                       -1
## 234           1                        1                        0
## 235           1                        0                        0
## 236           1                        0                        1
## 237           1                       -1                       -1
## 238           1                        1                        0
## 239           1                        0                        0
## 240           1                        0                        1
## 241           1                       -1                       -1
## 242           1                        1                        0
## 243           1                        0                        0
## 244           1                        0                        1
## 245           1                       -1                       -1
## 246           1                        1                        0
## 247           1                        0                        0
## 248           1                        0                        1
## 249           1                       -1                       -1
## 250           1                        1                        0
## 251           1                        0                        0
## 252           1                        0                        1
## 253           1                       -1                       -1
## 254           1                        1                        0
## 255           1                        0                        0
## 256           1                        0                        1
## 257           1                       -1                       -1
## 258           1                        1                        0
## 259           1                        0                        0
## 260           1                        0                        1
## 261           1                       -1                       -1
## 262           1                        1                        0
## 263           1                        0                        0
## 264           1                        0                        1
## 265           1                       -1                       -1
## 266           1                        1                        0
## 267           1                        0                        0
## 268           1                        0                        1
## 269           1                       -1                       -1
## 270           1                        1                        0
## 271           1                        0                        0
## 272           1                        0                        1
## 273           1                       -1                       -1
## 274           1                        1                        0
## 275           1                        0                        0
## 276           1                        0                        1
## 277           1                       -1                       -1
## 278           1                        1                        0
## 279           1                        0                        0
## 280           1                        0                        1
## 281           1                       -1                       -1
## 282           1                        1                        0
## 283           1                        0                        0
## 284           1                        0                        1
## 285           1                       -1                       -1
## 286           1                        1                        0
## 287           1                        0                        0
## 288           1                        0                        1
## 289           1                       -1                       -1
## 290           1                        1                        0
## 291           1                        0                        0
## 292           1                        0                        1
## 293           1                       -1                       -1
## 294           1                        1                        0
## 295           1                        0                        0
## 296           1                        0                        1
## 297           1                       -1                       -1
## 298           1                        1                        0
## 299           1                        0                        0
## 300           1                        0                        1
## 301           1                       -1                       -1
## 302           1                        1                        0
## 303           1                        0                        0
## 304           1                        0                        1
## 305           1                       -1                       -1
## 306           1                        1                        0
## 307           1                        0                        0
## 308           1                        0                        1
## 309           1                       -1                       -1
## 310           1                        1                        0
## 311           1                        0                        0
## 312           1                        0                        1
## 313           1                       -1                       -1
## 314           1                        1                        0
## 315           1                        0                        0
## 316           1                        0                        1
## 317           1                       -1                       -1
## 318           1                        1                        0
## 319           1                        0                        0
## 320           1                        0                        1
##     format_ITS_L6_AA$Group13 dph
## 1                         -1   1
## 2                          0   1
## 3                          1   1
## 4                          0   1
## 5                         -1   1
## 6                          0   1
## 7                          1   1
## 8                          0   1
## 9                         -1   1
## 10                         0   1
## 11                         1   1
## 12                         0   1
## 13                        -1   1
## 14                         0   1
## 15                         1   1
## 16                         0   1
## 17                        -1   1
## 18                         0   1
## 19                         1   1
## 20                         0   1
## 21                        -1   1
## 22                         0   1
## 23                         1   1
## 24                         0   1
## 25                        -1   1
## 26                         0   1
## 27                         1   1
## 28                         0   1
## 29                        -1   1
## 30                         0   1
## 31                         1   1
## 32                         0   1
## 33                        -1   1
## 34                         0   1
## 35                         1   1
## 36                         0   1
## 37                        -1   1
## 38                         0   1
## 39                         1   1
## 40                         0   1
## 41                        -1   4
## 42                         0   4
## 43                         1   4
## 44                         0   4
## 45                        -1   4
## 46                         0   4
## 47                         1   4
## 48                         0   4
## 49                        -1   4
## 50                         0   4
## 51                         1   4
## 52                         0   4
## 53                        -1   4
## 54                         0   4
## 55                         1   4
## 56                         0   4
## 57                        -1   4
## 58                         0   4
## 59                         1   4
## 60                         0   4
## 61                        -1   4
## 62                         0   4
## 63                         1   4
## 64                         0   4
## 65                        -1   4
## 66                         0   4
## 67                         1   4
## 68                         0   4
## 69                        -1   4
## 70                         0   4
## 71                         1   4
## 72                         0   4
## 73                        -1   4
## 74                         0   4
## 75                         1   4
## 76                         0   4
## 77                        -1   4
## 78                         0   4
## 79                         1   4
## 80                         0   4
## 81                        -1   7
## 82                         0   7
## 83                         1   7
## 84                         0   7
## 85                        -1   7
## 86                         0   7
## 87                         1   7
## 88                         0   7
## 89                        -1   7
## 90                         0   7
## 91                         1   7
## 92                         0   7
## 93                        -1   7
## 94                         0   7
## 95                         1   7
## 96                         0   7
## 97                        -1   7
## 98                         0   7
## 99                         1   7
## 100                        0   7
## 101                       -1   7
## 102                        0   7
## 103                        1   7
## 104                        0   7
## 105                       -1   7
## 106                        0   7
## 107                        1   7
## 108                        0   7
## 109                       -1   7
## 110                        0   7
## 111                        1   7
## 112                        0   7
## 113                       -1   7
## 114                        0   7
## 115                        1   7
## 116                        0   7
## 117                       -1   7
## 118                        0   7
## 119                        1   7
## 120                        0   7
## 121                       -1  14
## 122                        0  14
## 123                        1  14
## 124                        0  14
## 125                       -1  14
## 126                        0  14
## 127                        1  14
## 128                        0  14
## 129                       -1  14
## 130                        0  14
## 131                        1  14
## 132                        0  14
## 133                       -1  14
## 134                        0  14
## 135                        1  14
## 136                        0  14
## 137                       -1  14
## 138                        0  14
## 139                        1  14
## 140                        0  14
## 141                       -1  14
## 142                        0  14
## 143                        1  14
## 144                        0  14
## 145                       -1  14
## 146                        0  14
## 147                        1  14
## 148                        0  14
## 149                       -1  14
## 150                        0  14
## 151                        1  14
## 152                        0  14
## 153                       -1  14
## 154                        0  14
## 155                        1  14
## 156                        0  14
## 157                       -1  14
## 158                        0  14
## 159                        1  14
## 160                        0  14
## 161                       -1  21
## 162                        0  21
## 163                        1  21
## 164                        0  21
## 165                       -1  21
## 166                        0  21
## 167                        1  21
## 168                        0  21
## 169                       -1  21
## 170                        0  21
## 171                        1  21
## 172                        0  21
## 173                       -1  21
## 174                        0  21
## 175                        1  21
## 176                        0  21
## 177                       -1  21
## 178                        0  21
## 179                        1  21
## 180                        0  21
## 181                       -1  21
## 182                        0  21
## 183                        1  21
## 184                        0  21
## 185                       -1  21
## 186                        0  21
## 187                        1  21
## 188                        0  21
## 189                       -1  21
## 190                        0  21
## 191                        1  21
## 192                        0  21
## 193                       -1  21
## 194                        0  21
## 195                        1  21
## 196                        0  21
## 197                       -1  21
## 198                        0  21
## 199                        1  21
## 200                        0  21
## 201                       -1  28
## 202                        0  28
## 203                        1  28
## 204                        0  28
## 205                       -1  28
## 206                        0  28
## 207                        1  28
## 208                        0  28
## 209                       -1  28
## 210                        0  28
## 211                        1  28
## 212                        0  28
## 213                       -1  28
## 214                        0  28
## 215                        1  28
## 216                        0  28
## 217                       -1  28
## 218                        0  28
## 219                        1  28
## 220                        0  28
## 221                       -1  28
## 222                        0  28
## 223                        1  28
## 224                        0  28
## 225                       -1  28
## 226                        0  28
## 227                        1  28
## 228                        0  28
## 229                       -1  28
## 230                        0  28
## 231                        1  28
## 232                        0  28
## 233                       -1  28
## 234                        0  28
## 235                        1  28
## 236                        0  28
## 237                       -1  28
## 238                        0  28
## 239                        1  28
## 240                        0  28
## 241                       -1  35
## 242                        0  35
## 243                        1  35
## 244                        0  35
## 245                       -1  35
## 246                        0  35
## 247                        1  35
## 248                        0  35
## 249                       -1  35
## 250                        0  35
## 251                        1  35
## 252                        0  35
## 253                       -1  35
## 254                        0  35
## 255                        1  35
## 256                        0  35
## 257                       -1  35
## 258                        0  35
## 259                        1  35
## 260                        0  35
## 261                       -1  35
## 262                        0  35
## 263                        1  35
## 264                        0  35
## 265                       -1  35
## 266                        0  35
## 267                        1  35
## 268                        0  35
## 269                       -1  35
## 270                        0  35
## 271                        1  35
## 272                        0  35
## 273                       -1  35
## 274                        0  35
## 275                        1  35
## 276                        0  35
## 277                       -1  35
## 278                        0  35
## 279                        1  35
## 280                        0  35
## 281                       -1  42
## 282                        0  42
## 283                        1  42
## 284                        0  42
## 285                       -1  42
## 286                        0  42
## 287                        1  42
## 288                        0  42
## 289                       -1  42
## 290                        0  42
## 291                        1  42
## 292                        0  42
## 293                       -1  42
## 294                        0  42
## 295                        1  42
## 296                        0  42
## 297                       -1  42
## 298                        0  42
## 299                        1  42
## 300                        0  42
## 301                       -1  42
## 302                        0  42
## 303                        1  42
## 304                        0  42
## 305                       -1  42
## 306                        0  42
## 307                        1  42
## 308                        0  42
## 309                       -1  42
## 310                        0  42
## 311                        1  42
## 312                        0  42
## 313                       -1  42
## 314                        0  42
## 315                        1  42
## 316                        0  42
## 317                       -1  42
## 318                        0  42
## 319                        1  42
## 320                        0  42
## 
## $terms
## format_ITS_L6_AA[, 1:603] ~ format_ITS_L6_AA$Group1 + dph
## attr(,"variables")
## list(format_ITS_L6_AA[, 1:603], format_ITS_L6_AA$Group1, dph)
## attr(,"factors")
##                           format_ITS_L6_AA$Group1 dph
## format_ITS_L6_AA[, 1:603]                       0   0
## format_ITS_L6_AA$Group1                         1   0
## dph                                             0   1
## attr(,"term.labels")
## [1] "format_ITS_L6_AA$Group1" "dph"                    
## attr(,"order")
## [1] 1 1
## attr(,"intercept")
## [1] 1
## attr(,"response")
## [1] 1
## attr(,".Environment")
## <environment: R_GlobalEnv>
## 
## attr(,"class")
## [1] "adonis"
explains = data.frame(Method = c('RA','AA','RA','AA'),
                      Individual = c(0.31110,0.21089,0.29979,0.24770) * 100,
                      Segment = c(0.32671,0.27479,0.18011,0.11674) * 100,
                      DPH = c(0.08565,0.03220,0.07234,0.02779) * 100,
                      Kingdom = c('Bacteria','Bacteria','Fungi','Fungi')) 

exp_melt <- melt(explains)
## Using Method, Kingdom as id variables
colnames(exp_melt)[3:4] <- c('Factor','Explanation') 
exp_melt$Factor <- factor(exp_melt$Factor, levels = c('Individual', 'Segment', 'DPH'))
f13_3 <- ggplot(exp_melt, aes(x = Factor, y = Explanation, fill = Method)) +
  geom_bar(stat = 'identity', position = 'dodge') +
  scale_fill_manual(values = c('#E64B35','#4DBBD5')) +
  theme_bw() +
  theme(panel.grid.major=element_line(colour=NA),panel.grid.minor = element_line(colour=NA),
        axis.text.x = element_text(angle = 45, vjust = 1, hjust = 1)) +
  ylab('Explanation (%)') +
  facet_wrap(.~Kingdom)

f13_1 + f13_2 + f13_3

Figure S4 Pairwise correlations among microbial taxa abundance in QMP and relative microbiome profiling

Genus_16S_RA_ID <- read.table('../Data/02micro/output/L6_RA_16S.csv',header = T,sep = ',',row.names = 1)%>%
  colSums()
Genus_16S_RA0 <- read.table('../Data/02micro/output/L6_RA_16S.csv',header = T,sep = ',',row.names = 1) 
Genus_16S_RA <- Genus_16S_RA0[,Genus_16S_RA_ID>0.001*280]
Genus_16S_AA0 <- read.table('../Data/02micro/output/L6_AA_16S.csv',header = T,sep = ',',row.names = 1)
Genus_16S_AA <- Genus_16S_AA0[,Genus_16S_RA_ID>0.001*280]
Genus_16S_AA$Seg <- c(rep(c('Cecum','Duodenum','Ileum','Jejunum'),80))
Genus_16S_RA$Seg <- c(rep(c('Cecum','Duodenum','Ileum','Jejunum'),80))
rm(Genus_16S_RA_ID)
rm(Genus_16S_AA0)
rm(Genus_16S_RA0)
taxa_16S <- colnames(Genus_16S_RA)[1:58]
colnames(Genus_16S_AA)[1:58] <- colnames(Genus_16S_RA)[1:58] <- paste0('Genus',1:58)
Genus_16S_RA_C <- Genus_16S_RA[Genus_16S_RA$Seg=='Cecum',] %>%
  select(-c('Seg'))
Genus_16S_RA_D <- Genus_16S_RA[Genus_16S_RA$Seg=='Duodenum',] %>%
  select(-c('Seg'))
Genus_16S_RA_I <- Genus_16S_RA[Genus_16S_RA$Seg=='Ileum',] %>%
  select(-c('Seg'))
Genus_16S_RA_J <- Genus_16S_RA[Genus_16S_RA$Seg=='Jejunum',] %>%
  select(-c('Seg'))
Genus_16S_AA_C <- Genus_16S_AA[Genus_16S_AA$Seg=='Cecum',] %>%
  select(-c('Seg'))
Genus_16S_AA_D <- Genus_16S_AA[Genus_16S_AA$Seg=='Duodenum',] %>%
  select(-c('Seg'))
Genus_16S_AA_I <- Genus_16S_AA[Genus_16S_AA$Seg=='Ileum',] %>%
  select(-c('Seg'))
Genus_16S_AA_J <- Genus_16S_AA[Genus_16S_AA$Seg=='Jejunum',] %>%
  select(-c('Seg'))

# Define a function to create the matrix of correlation 
ab_2_cor <- function(x_RA, y_AA){
  p_RA <- matrix(, nrow = ncol(x_RA), ncol = ncol(x_RA))
  cor_RA <- matrix(, nrow = ncol(x_RA), ncol = ncol(x_RA))
  for(i in 1:ncol(x_RA)){
    for(j in 1:ncol(x_RA)){
      p_RA[i,j] <- cor.test(x_RA[,i], x_RA[,j], method = 'spearman')$p.value
      cor_RA[i,j] <- cor.test(x_RA[,i], x_RA[,j], method = 'spearman')$estimate
    }
  }
  cor_RA[is.na(cor_RA)] <- 0
  colnames(p_RA) <- rownames(p_RA) <- colnames(cor_RA) <- rownames(cor_RA) <- paste0('G',1:ncol(x_RA))
  
  p_AA <- matrix(, nrow = ncol(y_AA), ncol = ncol(y_AA))
  cor_AA <- matrix(, nrow = ncol(y_AA), ncol = ncol(y_AA))
  for(i in 1:ncol(y_AA)){
    for(j in 1:ncol(y_AA)){
      p_AA[i,j] <- cor.test(y_AA[,i], y_AA[,j], method = 'spearman')$p.value
      cor_AA[i,j] <- cor.test(y_AA[,i], y_AA[,j], method = 'spearman')$estimate
    }
  }
  colnames(p_AA) <- rownames(p_AA) <- colnames(cor_AA) <- rownames(cor_AA) <- paste0('G',1:ncol(y_AA))
  ind_RA <- which(lower.tri(cor_RA, diag = F), arr.ind = TRUE)
  Col_RA = dimnames(cor_RA)[[2]][ind_RA[,2]]
  Row_RA = dimnames(cor_RA)[[1]][ind_RA[,1]]
  Cor_RA = cor_RA[ind_RA]
  Pva_RA = p_RA[ind_RA]
  Q_RA = p.adjust(Pva_RA, method = 'BH')
  Cor_RA[Q_RA >= 0.05] <- 0
  out_RA <- data.frame(Col_RA,Row_RA,Cor_RA)
  
  ind_AA <- which(upper.tri(cor_AA, diag = F), arr.ind = TRUE)
  Col_AA = dimnames(cor_AA)[[2]][ind_AA[,2]]
  Row_AA = dimnames(cor_AA)[[1]][ind_AA[,1]]
  Cor_AA = cor_AA[ind_AA]
  Pva_AA = p_AA[ind_AA]
  Q_AA = p.adjust(Pva_AA, method = 'BH')
  Cor_AA[Q_AA >= 0.05] <- 0
  out_AA <- data.frame(Col_AA,Row_AA,Cor_AA)
  colnames(out_RA) <- colnames(out_AA) <- c('Col','Row','Cor')
  out_RA$Cat <- 'RA'
  out_AA$Cat <- 'AA'
  return(rbind(out_RA, out_AA))
}
Cecum <- ab_2_cor(Genus_16S_RA_C, Genus_16S_AA_C)
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
Cecum$Row <- factor(Cecum$Row, levels = paste0('G',1:58))
Cecum$Col <- factor(Cecum$Col, levels = paste0('G',1:58))
f14_C <- ggplot(Cecum, aes(x = Col, y = Row, color = Cor)) +
  geom_point(aes(size = abs(Cor))) +
  theme_bw() +
  theme(axis.text.x = element_blank(),axis.text.y = element_blank(),axis.ticks = element_blank(),
        panel.grid.major = element_line(color = NA), panel.grid.minor = element_line(color = NA)) +
  scale_color_gradient2(low="#3C5488", mid="white", high="#E64B35", midpoint=0)  +
  scale_size(range=c(0,2),
             breaks=c(0,0.25,0.5,0.75,1),
             labels=c("0","0.25","0.50","0.75","1.00"),
             name = "",
             guide="legend") +
  guides(size = 'none') +
  xlab('Absolute abundance') +
  ylab('Relative abundance') +
  ggtitle('Cecum')
Ileum <- ab_2_cor(Genus_16S_RA_I, Genus_16S_AA_I)
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
Ileum$Row <- factor(Ileum$Row, levels = paste0('G',1:58))
Ileum$Col <- factor(Ileum$Col, levels = paste0('G',1:58))
f14_I <- ggplot(Ileum, aes(x = Col, y = Row, color = Cor)) +
  geom_point(aes(size = abs(Cor))) +
  theme_bw() +
  theme(axis.text.x = element_blank(),axis.text.y = element_blank(),axis.ticks = element_blank(),
        panel.grid.major = element_line(color = NA), panel.grid.minor = element_line(color = NA)) +
  scale_color_gradient2(low="#3C5488", mid="white", high="#E64B35", midpoint=0)  +
  scale_size(range=c(0,2),
             breaks=c(0,0.25,0.5,0.75,1),
             labels=c("0","0.25","0.50","0.75","1.00"),
             name = "",
             guide="legend") +
  guides(size = 'none') +
  xlab('Absolute abundance') +
  ylab('Relative abundance') +
  ggtitle('Ileum')
Duodenum <- ab_2_cor(Genus_16S_RA_D, Genus_16S_AA_D)
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
Duodenum$Row <- factor(Duodenum$Row, levels = paste0('G',1:58))
Duodenum$Col <- factor(Duodenum$Col, levels = paste0('G',1:58))
f14_D <- ggplot(Duodenum, aes(x = Col, y = Row, color = Cor)) +
  geom_point(aes(size = abs(Cor))) +
  theme_bw() +
  theme(axis.text.x = element_blank(),axis.text.y = element_blank(),axis.ticks = element_blank(),
        panel.grid.major = element_line(color = NA), panel.grid.minor = element_line(color = NA)) +
  scale_color_gradient2(low="#3C5488", mid="white", high="#E64B35", midpoint=0)  +
  scale_size(range=c(0,2),
             breaks=c(0,0.25,0.5,0.75,1),
             labels=c("0","0.25","0.50","0.75","1.00"),
             name = "",
             guide="legend") +
  guides(size = 'none') +
  xlab('Absolute abundance') +
  ylab('Relative abundance') +
  ggtitle('Duodenum')

Jejunum <- ab_2_cor(Genus_16S_RA_J, Genus_16S_AA_J)
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
Jejunum$Row <- factor(Jejunum$Row, levels = paste0('G',1:58))
Jejunum$Col <- factor(Jejunum$Col, levels = paste0('G',1:58))
f14_J <- ggplot(Jejunum, aes(x = Col, y = Row, color = Cor)) +
  geom_point(aes(size = abs(Cor))) +
  theme_bw() +
  theme(axis.text.x = element_blank(),axis.text.y = element_blank(),axis.ticks = element_blank(),
        panel.grid.major = element_line(color = NA), panel.grid.minor = element_line(color = NA)) +
  scale_color_gradient2(low="#3C5488", mid="white", high="#E64B35", midpoint=0)  +
  scale_size(range=c(0,2),
             breaks=c(0,0.25,0.5,0.75,1),
             labels=c("0","0.25","0.50","0.75","1.00"),
             name = "",
             guide="legend") +
  guides(size = 'none') +
  xlab('Absolute abundance') +
  ylab('Relative abundance') +
  ggtitle('Jejunum')

cor2confusion <- function(correlation){
  CR1 <- correlation[correlation$Cat=='RA',]
  CR2 <- correlation[correlation$Cat=='AA',]
  CR1$Cat2 <- paste(CR1$Col,CR1$Row,sep = '-')
  CR1_1 <- CR1[,c(3,5)]
  CR2$Cat2 <- paste(CR2$Row,CR2$Col,sep = '-')
  CR2_1 <- CR2[,c(3,5)]
  colnames(CR1_1) <- c('CRA','Cat_R')
  colnames(CR2_1) <- c('CAA','Cat_A')
  CR_all <- merge(CR1_1,CR2_1,by.x = 'Cat_R',by.y = 'Cat_A')
  CR_all$CRA[CR_all$CRA>0] <- 'Pos'
  CR_all$CAA[CR_all$CAA>0] <- 'Pos'
  CR_all$CRA[CR_all$CRA<0] <- 'Neg'
  CR_all$CAA[CR_all$CAA<0] <- 'Neg'
  CR_all$CRA[CR_all$CRA==0] <- 'NS'
  CR_all$CAA[CR_all$CAA==0] <- 'NS'
  print(table(CR_all$CRA))
  print(table(CR_all$CAA))
  CR_final <- melt(table(CR_all$CRA,CR_all$CAA))
  colnames(CR_final) <- c("RA","AA",'Number')
  CR_final$Ratio <- round(CR_final$Number/sum(CR_final$Number) * 100, 1)
  CR_final$Cons[CR_final$RA=='Pos'&CR_final$AA=='Pos'] <- 'Consist'
  CR_final$Cons[CR_final$RA=='Neg'&CR_final$AA=='Neg'] <- 'Consist'
  CR_final$Cons[CR_final$RA=='NS'&CR_final$AA=='NS'] <- 'Consist'
  CR_final$Cons[is.na(CR_final$Cons)] <- 'Diff'
  return(CR_final[,c(1,2,4,5)])
}

Genus_ITS_RA_ID <- read.table('../Data/02micro/output/L6_RA_ITS.csv',header = T,sep = ',',row.names = 1)%>%
  colSums()
Genus_ITS_RA0 <- read.table('../Data/02micro/output/L6_RA_ITS.csv',header = T,sep = ',',row.names = 1) 
Genus_ITS_RA <- Genus_ITS_RA0[,Genus_ITS_RA_ID>0.001*280]
Genus_ITS_AA0 <- read.table('../Data/02micro/output/L6_AA_ITS.csv',header = T,sep = ',',row.names = 1)
Genus_ITS_AA <- Genus_ITS_AA0[,Genus_ITS_RA_ID>0.001*280]
Genus_ITS_AA$Seg <- c(rep(c('Cecum','Duodenum','Ileum','Jejunum'),80))
Genus_ITS_RA$Seg <- c(rep(c('Cecum','Duodenum','Ileum','Jejunum'),80))
taxa_ITS <- colnames(Genus_ITS_RA)[1:82]
colnames(Genus_ITS_AA)[1:82] <- colnames(Genus_ITS_RA)[1:82] <- paste0('Genus',1:82)

Genus_ITS_RA_C <- Genus_ITS_RA[Genus_ITS_RA$Seg=='Cecum',] %>%
  select(-c('Seg'))
Genus_ITS_RA_D <- Genus_ITS_RA[Genus_ITS_RA$Seg=='Duodenum',] %>%
  select(-c('Seg'))
Genus_ITS_RA_I <- Genus_ITS_RA[Genus_ITS_RA$Seg=='Ileum',] %>%
  select(-c('Seg'))
Genus_ITS_RA_J <- Genus_ITS_RA[Genus_ITS_RA$Seg=='Jejunum',] %>%
  select(-c('Seg'))
Genus_ITS_AA_C <- Genus_ITS_AA[Genus_ITS_AA$Seg=='Cecum',] %>%
  select(-c('Seg'))
Genus_ITS_AA_D <- Genus_ITS_AA[Genus_ITS_AA$Seg=='Duodenum',] %>%
  select(-c('Seg'))
Genus_ITS_AA_I <- Genus_ITS_AA[Genus_ITS_AA$Seg=='Ileum',] %>%
  select(-c('Seg'))
Genus_ITS_AA_J <- Genus_ITS_AA[Genus_ITS_AA$Seg=='Jejunum',] %>%
  select(-c('Seg'))

Cecum_ITS <- ab_2_cor(Genus_ITS_RA_C, Genus_ITS_AA_C)
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
Cecum_ITS[is.na(Cecum_ITS)] <- 0
Cecum_ITS$Row <- factor(Cecum_ITS$Row, levels = paste0('G',1:82))
Cecum_ITS$Col <- factor(Cecum_ITS$Col, levels = paste0('G',1:82))
p15_C <- ggplot(Cecum_ITS, aes(x = Col, y = Row, color = Cor)) +
  geom_point(aes(size = abs(Cor))) +
  theme_bw() +
  theme(axis.text.x = element_blank(),axis.text.y = element_blank(),axis.ticks = element_blank(),
        panel.grid.major = element_line(color = NA), panel.grid.minor = element_line(color = NA)) +
  scale_color_gradient2(low="#3C5488", mid="white", high="#E64B35", midpoint=0)  +
  scale_size(range=c(0,2),
             breaks=c(0,0.25,0.5,0.75,1),
             labels=c("0","0.25","0.50","0.75","1.00"),
             name = "",
             guide="legend") +
  guides(size = 'none') +
  xlab('Absolute abundance') +
  ylab('Relative abundance') +
  ggtitle('Cecum')

Ileum_ITS <- ab_2_cor(Genus_ITS_RA_I, Genus_ITS_AA_I)
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
Ileum_ITS[is.na(Ileum_ITS)] <- 0

Ileum_ITS$Row <- factor(Ileum_ITS$Row, levels = paste0('G',1:82))
Ileum_ITS$Col <- factor(Ileum_ITS$Col, levels = paste0('G',1:82))
p15_I <- ggplot(Ileum_ITS, aes(x = Col, y = Row, color = Cor)) +
  geom_point(aes(size = abs(Cor))) +
  theme_bw() +
  theme(axis.text.x = element_blank(),axis.text.y = element_blank(),axis.ticks = element_blank(),
        panel.grid.major = element_line(color = NA), panel.grid.minor = element_line(color = NA)) +
  scale_color_gradient2(low="#3C5488", mid="white", high="#E64B35", midpoint=0)  +
  scale_size(range=c(0,2),
             breaks=c(0,0.25,0.5,0.75,1),
             labels=c("0","0.25","0.50","0.75","1.00"),
             name = "",
             guide="legend") +
  guides(size = 'none') +
  xlab('Absolute abundance') +
  ylab('Relative abundance') +
  ggtitle('Ileum')

p15_I

Duodenum_ITS <- ab_2_cor(Genus_ITS_RA_D, Genus_ITS_AA_D)
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
Duodenum_ITS[is.na(Duodenum_ITS)] <- 0

Duodenum_ITS$Row <- factor(Duodenum_ITS$Row, levels = paste0('G',1:82))
Duodenum_ITS$Col <- factor(Duodenum_ITS$Col, levels = paste0('G',1:82))
p15_D <- ggplot(Duodenum_ITS, aes(x = Col, y = Row, color = Cor)) +
  geom_point(aes(size = abs(Cor))) +
  theme_bw() +
  theme(axis.text.x = element_blank(),axis.text.y = element_blank(),axis.ticks = element_blank(),
        panel.grid.major = element_line(color = NA), panel.grid.minor = element_line(color = NA)) +
  scale_color_gradient2(low="#3C5488", mid="white", high="#E64B35", midpoint=0)  +
  scale_size(range=c(0,2),
             breaks=c(0,0.25,0.5,0.75,1),
             labels=c("0","0.25","0.50","0.75","1.00"),
             name = "",
             guide="legend") +
  guides(size = 'none') +
  xlab('Absolute abundance') +
  ylab('Relative abundance') +
  ggtitle('Duodenum')
Jejunum_ITS <- ab_2_cor(Genus_ITS_RA_J, Genus_ITS_AA_J)
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(x_RA[, i], x_RA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
## Warning in cor(rank(x), rank(y)): the standard deviation is zero

## Warning in cor(rank(x), rank(y)): the standard deviation is zero
## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties

## Warning in cor.test.default(y_AA[, i], y_AA[, j], method = "spearman"): Cannot
## compute exact p-value with ties
Jejunum_ITS[is.na(Jejunum_ITS)] <- 0
Jejunum_ITS$Row <- factor(Jejunum_ITS$Row, levels = paste0('G',1:82))
Jejunum_ITS$Col <- factor(Jejunum_ITS$Col, levels = paste0('G',1:82))
p15_J <- ggplot(Jejunum_ITS, aes(x = Col, y = Row, color = Cor)) +
  geom_point(aes(size = abs(Cor))) +
  theme_bw() +
  theme(axis.text.x = element_blank(),axis.text.y = element_blank(),axis.ticks = element_blank(),
        panel.grid.major = element_line(color = NA), panel.grid.minor = element_line(color = NA)) +
  scale_color_gradient2(low="#3C5488", mid="white", high="#E64B35", midpoint=0)  +
  scale_size(range=c(0,2),
             breaks=c(0,0.25,0.5,0.75,1),
             labels=c("0","0.25","0.50","0.75","1.00"),
             name = "",
             guide="legend") +
  guides(size = 'none') +
  xlab('Absolute abundance') +
  ylab('Relative abundance') +
  ggtitle('Jejunum')

f14_D + f14_J + f14_I + f14_C  + p15_D + p15_J + p15_I + p15_C + plot_layout(nrow = 4)

Figure 2D The consistency of the correlations between the taxa based on absolute abundance and relative abundance in bacteria, respectively

confu_C <- cor2confusion(Cecum)
## 
## Neg  NS Pos 
## 166 672 815 
## 
## Neg  NS Pos 
## 119 577 957
confu_D <- cor2confusion(Duodenum) # AA Neg
## 
##  Neg   NS  Pos 
##   13 1041  599 
## 
##  Neg   NS  Pos 
##    4 1120  529
confu_I <- cor2confusion(Ileum) # AA Neg
## 
##  Neg   NS  Pos 
##   10  489 1154 
## 
##  Neg   NS  Pos 
##    5  558 1090
confu_J <- cor2confusion(Jejunum) 
## 
##  Neg   NS  Pos 
##   53  369 1231 
## 
## Neg  NS Pos 
##  53 646 954
confu_C_ITS <- cor2confusion(Cecum_ITS)
## 
##  Neg   NS  Pos 
##  443 1620 1258 
## 
##  Neg   NS  Pos 
##   37  719 2565
confu_D_ITS <- cor2confusion(Duodenum_ITS)
## 
##  Neg   NS  Pos 
##  236 2378  707 
## 
##  Neg   NS  Pos 
##  200 1677 1444
confu_I_ITS <- cor2confusion(Ileum_ITS) # AA Neg
## 
##  Neg   NS  Pos 
##  313 1714 1294 
## 
##  Neg   NS  Pos 
##   11 1426 1884
confu_J_ITS <- cor2confusion(Jejunum_ITS) # AA Neg
## 
##  Neg   NS  Pos 
##  646 1561 1114 
## 
##  Neg   NS  Pos 
##   58 1618 1645
add_confu <- data.frame(RA = c('Pos','Neg','NS'),
                        AA = c('Neg','Neg','Neg'),
                        Ratio = c(0.0,0.0,0.0),
                        Cons = c('Diff','Consist','Diff'))
confu_D <- rbind(confu_D, add_confu)
confu_I <- rbind(confu_I, add_confu)
confu_I_ITS <- rbind(confu_I_ITS, add_confu)
confu_J_ITS <- rbind(confu_J_ITS, add_confu)

relevel_matrix <- function(confusion_matrix){
  confusion_matrix$RA <- factor(confusion_matrix$RA, levels = c('Pos','Neg','NS'))
  confusion_matrix$AA <- factor(confusion_matrix$AA, levels = c('NS','Neg','Pos'))
  return(confusion_matrix)
}
confu_D <- relevel_matrix(confu_D)
confu_J <- relevel_matrix(confu_J)
confu_I <- relevel_matrix(confu_I)
confu_C <- relevel_matrix(confu_C)
confu_D_ITS <- relevel_matrix(confu_D_ITS)
confu_J_ITS <- relevel_matrix(confu_J_ITS)
confu_I_ITS <- relevel_matrix(confu_I_ITS)
confu_C_ITS <- relevel_matrix(confu_C_ITS)

p16_1 <- ggplot(confu_D,aes(x = RA, y = AA)) +
  geom_tile(aes(fill = Cons)) +
  geom_text(aes(label = Ratio,size = 4)) +
  theme_bw() + 
  theme(legend.position = 'none',panel.grid.major = element_line(color = NA), 
        panel.grid.minor = element_line(color = NA),panel.border = element_blank(),
        axis.ticks = element_blank()) +
  scale_fill_manual(values = c('#E64B35','#4DBBD5')) +
  xlab('Relative abundance') + ylab('Absolute abundance') +
  ggtitle('Duodenum') + scale_x_discrete(position = "top")
p16_2 <- ggplot(confu_J,aes(x = RA, y = AA)) +
  geom_tile(aes(fill = Cons)) +
  geom_text(aes(label = Ratio,size = 4)) +
  theme_bw() + 
  theme(legend.position = 'none',panel.grid.major = element_line(color = NA), 
        panel.grid.minor = element_line(color = NA),panel.border = element_blank(),
        axis.ticks = element_blank()) +
  scale_fill_manual(values = c('#E64B35','#4DBBD5')) +
  xlab('Relative abundance') + ylab('Absolute abundance') +
  ggtitle('Jejunum') + scale_x_discrete(position = "top")
p16_3 <- ggplot(confu_I,aes(x = RA, y = AA)) +
  geom_tile(aes(fill = Cons)) +
  geom_text(aes(label = Ratio,size = 4)) +
  theme_bw() + 
  theme(legend.position = 'none',panel.grid.major = element_line(color = NA), 
        panel.grid.minor = element_line(color = NA),panel.border = element_blank(),
        axis.ticks = element_blank()) +
  scale_fill_manual(values = c('#E64B35','#4DBBD5')) +
  xlab('Relative abundance') + ylab('Absolute abundance') +
  ggtitle('Ileum') + scale_x_discrete(position = "top")
p16_4 <- ggplot(confu_C,aes(x = RA, y = AA)) +
  geom_tile(aes(fill = Cons)) +
  geom_text(aes(label = Ratio,size = 4)) +
  theme_bw() + 
  theme(legend.position = 'none',panel.grid.major = element_line(color = NA), 
        panel.grid.minor = element_line(color = NA),panel.border = element_blank(),
        axis.ticks = element_blank()) +
  scale_fill_manual(values = c('#E64B35','#4DBBD5')) +
  xlab('Relative abundance') + ylab('Absolute abundance') +
  ggtitle('Cecum') + scale_x_discrete(position = "top")
p17_1 <- ggplot(confu_D_ITS,aes(x = RA, y = AA)) +
  geom_tile(aes(fill = Cons)) +
  geom_text(aes(label = Ratio,size = 4)) +
  theme_bw() + 
  theme(legend.position = 'none',panel.grid.major = element_line(color = NA), 
        panel.grid.minor = element_line(color = NA),panel.border = element_blank(),
        axis.ticks = element_blank()) +
  scale_fill_manual(values = c('#E64B35','#4DBBD5')) +
  xlab('Relative abundance') + ylab('Absolute abundance') +
  ggtitle('Duodenum') + scale_x_discrete(position = "top")
p17_2 <- ggplot(confu_J_ITS,aes(x = RA, y = AA)) +
  geom_tile(aes(fill = Cons)) +
  geom_text(aes(label = Ratio,size = 4)) +
  theme_bw() + 
  theme(legend.position = 'none',panel.grid.major = element_line(color = NA), 
        panel.grid.minor = element_line(color = NA),panel.border = element_blank(),
        axis.ticks = element_blank()) +
  scale_fill_manual(values = c('#E64B35','#4DBBD5')) +
  xlab('Relative abundance') + ylab('Absolute abundance') +
  ggtitle('Jejunum') + scale_x_discrete(position = "top")
p17_3 <- ggplot(confu_I_ITS,aes(x = RA, y = AA)) +
  geom_tile(aes(fill = Cons)) +
  geom_text(aes(label = Ratio,size = 4)) +
  theme_bw() + 
  theme(legend.position = 'none',panel.grid.major = element_line(color = NA), 
        panel.grid.minor = element_line(color = NA),panel.border = element_blank(),
        axis.ticks = element_blank()) +
  scale_fill_manual(values = c('#E64B35','#4DBBD5')) +
  xlab('Relative abundance') + ylab('Absolute abundance') +
  ggtitle('Ileum') + scale_x_discrete(position = "top")
p17_4 <- ggplot(confu_C_ITS,aes(x = RA, y = AA)) +
  geom_tile(aes(fill = Cons)) +
  geom_text(aes(label = Ratio,size = 4)) +
  theme_bw() + 
  theme(legend.position = 'none',panel.grid.major = element_line(color = NA), 
        panel.grid.minor = element_line(color = NA),panel.border = element_blank(),
        axis.ticks = element_blank()) +
  scale_fill_manual(values = c('#E64B35','#4DBBD5')) +
  xlab('Relative abundance') + ylab('Absolute abundance') +
  ggtitle('Cecum') + 
  scale_x_discrete(position = "top") 
p16_1 + p16_2 + p16_3 + p16_4 + p17_1 + p17_2 + p17_3 + p17_4 + plot_layout(nrow = 2)